package com.yuqiaotech.dbpro.filter;

import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Date;
import java.sql.NClob;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLClientInfoException;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Savepoint;
import java.sql.Statement;
import java.sql.Struct;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Wrapper;
import java.util.Calendar;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import com.yuqiaotech.dbpro.proxy.YQDataSource;
import com.yuqiaotech.dbpro.proxy.jdbc.CallableStatementProxy;
import com.yuqiaotech.dbpro.proxy.jdbc.CallableStatementProxyImpl;
import com.yuqiaotech.dbpro.proxy.jdbc.ClobProxy;
import com.yuqiaotech.dbpro.proxy.jdbc.ClobProxyImpl;
import com.yuqiaotech.dbpro.proxy.jdbc.ConnectionProxy;
import com.yuqiaotech.dbpro.proxy.jdbc.ConnectionProxyImpl;
import com.yuqiaotech.dbpro.proxy.jdbc.NClobProxy;
import com.yuqiaotech.dbpro.proxy.jdbc.NClobProxyImpl;
import com.yuqiaotech.dbpro.proxy.jdbc.PreparedStatementProxy;
import com.yuqiaotech.dbpro.proxy.jdbc.PreparedStatementProxyImpl;
import com.yuqiaotech.dbpro.proxy.jdbc.ResultSetMetaDataProxy;
import com.yuqiaotech.dbpro.proxy.jdbc.ResultSetMetaDataProxyImpl;
import com.yuqiaotech.dbpro.proxy.jdbc.ResultSetProxy;
import com.yuqiaotech.dbpro.proxy.jdbc.ResultSetProxyImpl;
import com.yuqiaotech.dbpro.proxy.jdbc.StatementProxy;
import com.yuqiaotech.dbpro.proxy.jdbc.StatementProxyImpl;

public class FilterChainImpl implements FilterChain {

	protected int pos = 0;

	private final YQDataSource dataSource;

	private final int filterSize;

	public FilterChainImpl(YQDataSource dataSource) {
		this.dataSource = dataSource;
		this.filterSize = getFilters().size();
	}

	public ConnectionProxy connection_connect() throws SQLException {
		if (this.pos < filterSize) {
			return nextFilter().connection_connect(this);
		}

		Connection nativeConnection = dataSource.getRawDataSource()
				.getConnection();
		return wrap(nativeConnection);
	}

	@Override
	public YQDataSource getDataSource() {
		return dataSource;
	}

	@Override
	public int getFilterSize() {
		return filterSize;
	}

	public void reset() {
		pos = 0;
	}

	public ConnectionProxy wrap(Connection connection) {
		if (connection == null) {
			return null;
		}
		return new ConnectionProxyImpl(dataSource, connection,
				dataSource.createConnectionId());
	}

	@Override
	public boolean isWrapperFor(Wrapper wrapper, Class<?> iface)
			throws SQLException {
		if (this.pos < filterSize) {
			return nextFilter().isWrapperFor(this, wrapper, iface);
		}

		// // if driver is for jdbc 3.0
		if (iface.isInstance(wrapper)) {
			return true;
		}

		return wrapper.isWrapperFor(iface);
	}

	@SuppressWarnings("unchecked")
	@Override
	public <T> T unwrap(Wrapper wrapper, Class<T> iface) throws SQLException {
		if (this.pos < filterSize) {
			return nextFilter().unwrap(this, wrapper, iface);
		}

		if (iface == null) {
			return null;
		}

		// if driver is for jdbc 3.0
		if (iface.isAssignableFrom(wrapper.getClass())) {
			return (T) wrapper;
		}

		return wrapper.unwrap(iface);
	}

	@Override
	public ConnectionProxy connection_connect(Properties info)
			throws SQLException {

		if (this.pos < filterSize) {
			return nextFilter().connection_connect(this, info);
		}

		return null;
	}

	@Override
	public void connection_clearWarnings(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().connection_clearWarnings(this, connection);

			return;

		}

		connection.getRawObject().clearWarnings();

	}

	@Override
	public void connection_close(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().connection_close(this, connection);

			return;

		}

		connection.getRawObject().close();

		connection.clearAttributes();

	}

	@Override
	public void connection_commit(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().connection_commit(this, connection);

			return;

		}

		connection.getRawObject().commit();

	}

	@Override
	public Array connection_createArrayOf(ConnectionProxy connection,
			String typeName, Object[] elements)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_createArrayOf(this, connection,
					typeName, elements);

		}

		return connection.getRawObject().createArrayOf(typeName, elements);

	}

	@Override
	public Blob connection_createBlob(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_createBlob(this, connection);

		}

		return connection.getRawObject().createBlob();

	}

	@Override
	public Clob connection_createClob(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_createClob(this, connection);

		}

		Clob clob = connection.getRawObject().createClob();

		return wrap(connection, clob);

	}

	@Override
	public NClob connection_createNClob(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_createNClob(this, connection);

		}

		NClob nclob = connection.getRawObject().createNClob();

		return wrap(connection, nclob);

	}

	@Override
	public SQLXML connection_createSQLXML(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_createSQLXML(this, connection);

		}

		return connection.getRawObject().createSQLXML();

	}

	@Override
	public StatementProxy connection_createStatement(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_createStatement(this, connection);

		}

		Statement statement = connection.getRawObject().createStatement();

		return wrap(connection, statement);

	}

	@Override
	public StatementProxy connection_createStatement(
			ConnectionProxy connection, int resultSetType,

			int resultSetConcurrency) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_createStatement(this, connection,
					resultSetType, resultSetConcurrency);

		}

		Statement statement = connection.getRawObject().createStatement(
				resultSetType, resultSetConcurrency);

		return wrap(connection, statement);

	}

	@Override
	public StatementProxy connection_createStatement(
			ConnectionProxy connection, int resultSetType,

			int resultSetConcurrency, int resultSetHoldability)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_createStatement(this, connection,
					resultSetType, resultSetConcurrency,

					resultSetHoldability);

		}

		Statement statement = connection.getRawObject().createStatement(
				resultSetType, resultSetConcurrency,

				resultSetHoldability);

		return wrap(connection, statement);

	}

	@Override
	public Struct connection_createStruct(ConnectionProxy connection,
			String typeName, Object[] attributes)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_createStruct(this, connection,
					typeName, attributes);

		}

		return connection.getRawObject().createStruct(typeName, attributes);

	}

	@Override
	public boolean connection_getAutoCommit(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_getAutoCommit(this, connection);

		}

		return connection.getRawObject().getAutoCommit();

	}

	@Override
	public String connection_getCatalog(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_getCatalog(this, connection);

		}

		return connection.getRawObject().getCatalog();

	}

	@Override
	public Properties connection_getClientInfo(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_getClientInfo(this, connection);

		}

		return connection.getRawObject().getClientInfo();

	}

	@Override
	public String connection_getClientInfo(ConnectionProxy connection,
			String name) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.connection_getClientInfo(this, connection, name);

		}

		return connection.getRawObject().getClientInfo(name);

	}

	public List<Filter> getFilters() {

		return dataSource.getProxyFilters();

	}

	@Override
	public int connection_getHoldability(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_getHoldability(this, connection);

		}

		return connection.getRawObject().getHoldability();

	}

	@Override
	public DatabaseMetaData connection_getMetaData(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_getMetaData(this, connection);

		}

		// DatabaseMetaData

		DatabaseMetaData rawDatabaseMetaData = connection.getRawObject()
				.getMetaData();

		return rawDatabaseMetaData;

	}

	@Override
	public int connection_getTransactionIsolation(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_getTransactionIsolation(this,
					connection);

		}

		return connection.getRawObject().getTransactionIsolation();

	}

	@Override
	public Map<String, Class<?>> connection_getTypeMap(
			ConnectionProxy connection) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_getTypeMap(this, connection);

		}

		return connection.getRawObject().getTypeMap();

	}

	@Override
	public SQLWarning connection_getWarnings(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_getWarnings(this, connection);

		}

		return connection.getRawObject().getWarnings();

	}

	@Override
	public boolean connection_isClosed(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_isClosed(this, connection);

		}

		return connection.getRawObject().isClosed();

	}

	@Override
	public boolean connection_isReadOnly(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_isReadOnly(this, connection);

		}

		return connection.getRawObject().isReadOnly();

	}

	@Override
	public boolean connection_isValid(ConnectionProxy connection, int timeout)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_isValid(this, connection, timeout);

		}

		return connection.getRawObject().isValid(timeout);

	}

	@Override
	public String connection_nativeSQL(ConnectionProxy connection, String sql)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_nativeSQL(this, connection, sql);

		}

		return connection.getRawObject().nativeSQL(sql);

	}

	private Filter nextFilter() {

		Filter filter = getFilters().get(pos++);

		return filter;

	}

	@Override
	public CallableStatementProxy connection_prepareCall(
			ConnectionProxy connection, String sql) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_prepareCall(this, connection, sql);

		}

		CallableStatement statement = connection.getRawObject()
				.prepareCall(sql);

		return wrap(connection, statement, sql);

	}

	@Override
	public CallableStatementProxy connection_prepareCall(
			ConnectionProxy connection, String sql, int resultSetType,

			int resultSetConcurrency) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_prepareCall(this, connection, sql,
					resultSetType, resultSetConcurrency);

		}

		CallableStatement statement = connection.getRawObject().prepareCall(
				sql, resultSetType, resultSetConcurrency);

		return wrap(connection, statement, sql);

	}

	@Override
	public CallableStatementProxy connection_prepareCall(
			ConnectionProxy connection, String sql, int resultSetType,

			int resultSetConcurrency, int resultSetHoldability)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_prepareCall(this, connection, sql,
					resultSetType, resultSetConcurrency,

					resultSetHoldability);

		}

		CallableStatement statement = connection.getRawObject().prepareCall(
				sql, resultSetType, resultSetConcurrency,

				resultSetHoldability);

		return wrap(connection, statement, sql);

	}

	@Override
	public PreparedStatementProxy connection_prepareStatement(
			ConnectionProxy connection, String sql)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_prepareStatement(this, connection,
					sql);

		}

		PreparedStatement statement = connection.getRawObject()
				.prepareStatement(sql);

		return wrap(connection, statement, sql);

	}

	@Override
	public PreparedStatementProxy connection_prepareStatement(
			ConnectionProxy connection, String sql,

			int autoGeneratedKeys) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_prepareStatement(this, connection,
					sql, autoGeneratedKeys);

		}

		PreparedStatement statement = connection.getRawObject()
				.prepareStatement(sql, autoGeneratedKeys);

		return wrap(connection, statement, sql);

	}

	@Override
	public PreparedStatementProxy connection_prepareStatement(
			ConnectionProxy connection, String sql,

			int resultSetType, int resultSetConcurrency)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_prepareStatement(this, connection,
					sql, resultSetType, resultSetConcurrency);

		}

		PreparedStatement statement = connection.getRawObject()
				.prepareStatement(sql, resultSetType,

				resultSetConcurrency);

		return wrap(connection, statement, sql);

	}

	@Override
	public PreparedStatementProxy connection_prepareStatement(
			ConnectionProxy connection, String sql,

			int resultSetType, int resultSetConcurrency,

			int resultSetHoldability) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_prepareStatement(this, connection,
					sql, resultSetType, resultSetConcurrency,

					resultSetHoldability);

		}

		PreparedStatement statement = connection.getRawObject()
				.prepareStatement(sql, resultSetType,

				resultSetConcurrency,

				resultSetHoldability);

		return wrap(connection, statement, sql);

	}

	@Override
	public PreparedStatementProxy connection_prepareStatement(
			ConnectionProxy connection, String sql,

			int[] columnIndexes) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_prepareStatement(this, connection,
					sql, columnIndexes);

		}

		PreparedStatement statement = connection.getRawObject()
				.prepareStatement(sql, columnIndexes);

		return wrap(connection, statement, sql);

	}

	@Override
	public PreparedStatementProxy connection_prepareStatement(
			ConnectionProxy connection, String sql,

			String[] columnNames) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_prepareStatement(this, connection,
					sql, columnNames);

		}

		PreparedStatement statement = connection.getRawObject()
				.prepareStatement(sql, columnNames);

		return wrap(connection, statement, sql);

	}

	@Override
	public void connection_releaseSavepoint(ConnectionProxy connection,
			Savepoint savepoint) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().connection_releaseSavepoint(this, connection,
					savepoint);

			return;

		}

		connection.getRawObject().releaseSavepoint(savepoint);

	}

	@Override
	public void connection_rollback(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().connection_rollback(this, connection);

			return;

		}

		connection.getRawObject().rollback();

	}

	@Override
	public void connection_rollback(ConnectionProxy connection,
			Savepoint savepoint) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().connection_rollback(this, connection, savepoint);

			return;

		}

		connection.getRawObject().rollback(savepoint);

	}

	@Override
	public void connection_setAutoCommit(ConnectionProxy connection,
			boolean autoCommit) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().connection_setAutoCommit(this, connection, autoCommit);

			return;

		}

		connection.getRawObject().setAutoCommit(autoCommit);

	}

	@Override
	public void connection_setCatalog(ConnectionProxy connection, String catalog)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().connection_setCatalog(this, connection, catalog);

			return;

		}

		connection.getRawObject().setCatalog(catalog);

	}

	@Override
	public void connection_setClientInfo(ConnectionProxy connection,
			Properties properties)

	throws SQLClientInfoException {

		if (this.pos < filterSize) {

			nextFilter().connection_setClientInfo(this, connection, properties);

			return;

		}

		connection.getRawObject().setClientInfo(properties);

	}

	@Override
	public void connection_setClientInfo(ConnectionProxy connection,
			String name, String value)

	throws SQLClientInfoException {

		if (this.pos < filterSize) {

			nextFilter()
					.connection_setClientInfo(this, connection, name, value);

			return;

		}

		connection.getRawObject().setClientInfo(name, value);

	}

	@Override
	public void connection_setHoldability(ConnectionProxy connection,
			int holdability) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().connection_setHoldability(this, connection,
					holdability);

			return;

		}

		connection.getRawObject().setHoldability(holdability);

	}

	@Override
	public void connection_setReadOnly(ConnectionProxy connection,
			boolean readOnly) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().connection_setReadOnly(this, connection, readOnly);

			return;

		}

		connection.getRawObject().setReadOnly(readOnly);

	}

	@Override
	public Savepoint connection_setSavepoint(ConnectionProxy connection)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_setSavepoint(this, connection);

		}

		return connection.getRawObject().setSavepoint();

	}

	@Override
	public Savepoint connection_setSavepoint(ConnectionProxy connection,
			String name) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().connection_setSavepoint(this, connection, name);

		}

		return connection.getRawObject().setSavepoint(name);

	}

	@Override
	public void connection_setTransactionIsolation(ConnectionProxy connection,
			int level) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().connection_setTransactionIsolation(this, connection,
					level);

			return;

		}

		connection.getRawObject().setTransactionIsolation(level);

	}

	@Override
	public void connection_setTypeMap(ConnectionProxy connection,
			Map<String, Class<?>> map) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().connection_setTypeMap(this, connection, map);

			return;

		}

		connection.getRawObject().setTypeMap(map);

	}

	// ///////////////////////////////////////

	@Override
	public boolean resultSet_next(ResultSetProxy resultSet) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_next(this, resultSet);

		}

		return resultSet.getResultSetRaw().next();

	}

	@Override
	public void resultSet_close(ResultSetProxy resultSet) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_close(this, resultSet);

			return;

		}

		resultSet.getResultSetRaw().close();

		resultSet.clearAttributes();

	}

	@Override
	public boolean resultSet_wasNull(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_wasNull(this, resultSet);

		}

		return resultSet.getResultSetRaw().wasNull();

	}

	@Override
	public String resultSet_getString(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getString(this, resultSet,
					columnIndex);

		}

		return resultSet.getResultSetRaw().getString(columnIndex);

	}

	@Override
	public boolean resultSet_getBoolean(ResultSetProxy resultSet,
			int columnIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getBoolean(this, resultSet,
					columnIndex);

		}

		return resultSet.getResultSetRaw().getBoolean(columnIndex);

	}

	@Override
	public byte resultSet_getByte(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getByte(this, resultSet, columnIndex);

		}

		return resultSet.getResultSetRaw().getByte(columnIndex);

	}

	@Override
	public short resultSet_getShort(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.resultSet_getShort(this, resultSet, columnIndex);

		}

		return resultSet.getResultSetRaw().getShort(columnIndex);

	}

	@Override
	public int resultSet_getInt(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getInt(this, resultSet, columnIndex);

		}

		return resultSet.getResultSetRaw().getInt(columnIndex);

	}

	@Override
	public long resultSet_getLong(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getLong(this, resultSet, columnIndex);

		}

		return resultSet.getResultSetRaw().getLong(columnIndex);

	}

	@Override
	public float resultSet_getFloat(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.resultSet_getFloat(this, resultSet, columnIndex);

		}

		return resultSet.getResultSetRaw().getFloat(columnIndex);

	}

	@Override
	public double resultSet_getDouble(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getDouble(this, resultSet,
					columnIndex);

		}

		return resultSet.getResultSetRaw().getDouble(columnIndex);

	}

	@SuppressWarnings("deprecation")
	@Override
	public BigDecimal resultSet_getBigDecimal(ResultSetProxy resultSet,
			int columnIndex, int scale) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getBigDecimal(this, resultSet,
					columnIndex, scale);

		}

		return resultSet.getResultSetRaw().getBigDecimal(columnIndex, scale);

	}

	@Override
	public byte[] resultSet_getBytes(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.resultSet_getBytes(this, resultSet, columnIndex);

		}

		return resultSet.getResultSetRaw().getBytes(columnIndex);

	}

	@Override
	public java.sql.Date resultSet_getDate(ResultSetProxy resultSet,
			int columnIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getDate(this, resultSet, columnIndex);

		}

		return resultSet.getResultSetRaw().getDate(columnIndex);

	}

	@Override
	public java.sql.Time resultSet_getTime(ResultSetProxy resultSet,
			int columnIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getTime(this, resultSet, columnIndex);

		}

		return resultSet.getResultSetRaw().getTime(columnIndex);

	}

	@Override
	public java.sql.Timestamp resultSet_getTimestamp(ResultSetProxy resultSet,
			int columnIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getTimestamp(this, resultSet,
					columnIndex);

		}

		return resultSet.getResultSetRaw().getTimestamp(columnIndex);

	}

	@Override
	public java.io.InputStream resultSet_getAsciiStream(
			ResultSetProxy resultSet, int columnIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getAsciiStream(this, resultSet,
					columnIndex);

		}

		return resultSet.getResultSetRaw().getAsciiStream(columnIndex);

	}

	@SuppressWarnings("deprecation")
	@Override
	public java.io.InputStream resultSet_getUnicodeStream(
			ResultSetProxy resultSet, int columnIndex)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getUnicodeStream(this, resultSet,
					columnIndex);

		}

		return resultSet.getResultSetRaw().getUnicodeStream(columnIndex);

	}

	@Override
	public java.io.InputStream resultSet_getBinaryStream(
			ResultSetProxy resultSet, int columnIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getBinaryStream(this, resultSet,
					columnIndex);

		}

		return resultSet.getResultSetRaw().getBinaryStream(columnIndex);

	}

	@Override
	public String resultSet_getString(ResultSetProxy resultSet,
			String columnLabel) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getString(this, resultSet,
					columnLabel);

		}

		return resultSet.getResultSetRaw().getString(columnLabel);

	}

	@Override
	public boolean resultSet_getBoolean(ResultSetProxy resultSet,
			String columnLabel) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getBoolean(this, resultSet,
					columnLabel);

		}

		return resultSet.getResultSetRaw().getBoolean(columnLabel);

	}

	@Override
	public byte resultSet_getByte(ResultSetProxy resultSet, String columnLabel)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getByte(this, resultSet, columnLabel);

		}

		return resultSet.getResultSetRaw().getByte(columnLabel);

	}

	@Override
	public short resultSet_getShort(ResultSetProxy resultSet, String columnLabel)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.resultSet_getShort(this, resultSet, columnLabel);

		}

		return resultSet.getResultSetRaw().getShort(columnLabel);

	}

	@Override
	public int resultSet_getInt(ResultSetProxy resultSet, String columnLabel)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getInt(this, resultSet, columnLabel);

		}

		return resultSet.getResultSetRaw().getInt(columnLabel);

	}

	@Override
	public long resultSet_getLong(ResultSetProxy resultSet, String columnLabel)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getLong(this, resultSet, columnLabel);

		}

		return resultSet.getResultSetRaw().getLong(columnLabel);

	}

	@Override
	public float resultSet_getFloat(ResultSetProxy resultSet, String columnLabel)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.resultSet_getFloat(this, resultSet, columnLabel);

		}

		return resultSet.getResultSetRaw().getFloat(columnLabel);

	}

	@Override
	public double resultSet_getDouble(ResultSetProxy resultSet,
			String columnLabel) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getDouble(this, resultSet,
					columnLabel);

		}

		return resultSet.getResultSetRaw().getDouble(columnLabel);

	}

	@SuppressWarnings("deprecation")
	@Override
	public BigDecimal resultSet_getBigDecimal(ResultSetProxy resultSet,
			String columnLabel, int scale)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getBigDecimal(this, resultSet,
					columnLabel, scale);

		}

		return resultSet.getResultSetRaw().getBigDecimal(columnLabel, scale);

	}

	@Override
	public byte[] resultSet_getBytes(ResultSetProxy resultSet,
			String columnLabel) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.resultSet_getBytes(this, resultSet, columnLabel);

		}

		return resultSet.getResultSetRaw().getBytes(columnLabel);

	}

	@Override
	public java.sql.Date resultSet_getDate(ResultSetProxy resultSet,
			String columnLabel) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getDate(this, resultSet, columnLabel);

		}

		return resultSet.getResultSetRaw().getDate(columnLabel);

	}

	@Override
	public java.sql.Time resultSet_getTime(ResultSetProxy resultSet,
			String columnLabel) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getTime(this, resultSet, columnLabel);

		}

		return resultSet.getResultSetRaw().getTime(columnLabel);

	}

	@Override
	public java.sql.Timestamp resultSet_getTimestamp(ResultSetProxy resultSet,
			String columnLabel) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getTimestamp(this, resultSet,
					columnLabel);

		}

		return resultSet.getResultSetRaw().getTimestamp(columnLabel);

	}

	@Override
	public java.io.InputStream resultSet_getAsciiStream(
			ResultSetProxy resultSet, String columnLabel)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getAsciiStream(this, resultSet,
					columnLabel);

		}

		return resultSet.getResultSetRaw().getAsciiStream(columnLabel);

	}

	@SuppressWarnings("deprecation")
	@Override
	public java.io.InputStream resultSet_getUnicodeStream(
			ResultSetProxy resultSet, String columnLabel)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getUnicodeStream(this, resultSet,
					columnLabel);

		}

		return resultSet.getResultSetRaw().getUnicodeStream(columnLabel);

	}

	@Override
	public java.io.InputStream resultSet_getBinaryStream(
			ResultSetProxy resultSet, String columnLabel)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getBinaryStream(this, resultSet,
					columnLabel);

		}

		return resultSet.getResultSetRaw().getBinaryStream(columnLabel);

	}

	@Override
	public SQLWarning resultSet_getWarnings(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getWarnings(this, resultSet);

		}

		return resultSet.getResultSetRaw().getWarnings();

	}

	@Override
	public void resultSet_clearWarnings(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_clearWarnings(this, resultSet);

			return;

		}

		resultSet.getResultSetRaw().clearWarnings();

	}

	@Override
	public String resultSet_getCursorName(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getCursorName(this, resultSet);

		}

		return resultSet.getResultSetRaw().getCursorName();

	}

	@Override
	public ResultSetMetaData resultSet_getMetaData(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getMetaData(this, resultSet);

		}

		return wrap(resultSet.getResultSetRaw().getMetaData(), resultSet);

	}

	@Override
	public Object resultSet_getObject(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getObject(this, resultSet,
					columnIndex);

		}

		Object obj = resultSet.getResultSetRaw().getObject(columnIndex);

		if (obj instanceof ResultSet) {

			return wrap(resultSet.getStatementProxy(), (ResultSet) obj);

		}

		if (obj instanceof Clob) {

			return wrap(resultSet.getStatementProxy(), (Clob) obj);

		}

		return obj;

	}

	@Override
	public Object resultSet_getObject(ResultSetProxy resultSet,
			String columnLabel) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getObject(this, resultSet,
					columnLabel);

		}

		Object obj = resultSet.getResultSetRaw().getObject(columnLabel);

		if (obj instanceof ResultSet) {

			return wrap(resultSet.getStatementProxy(), (ResultSet) obj);

		}

		if (obj instanceof Clob) {

			return wrap(resultSet.getStatementProxy(), (Clob) obj);

		}

		return obj;

	}

	@Override
	public int resultSet_findColumn(ResultSetProxy resultSet, String columnLabel)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_findColumn(this, resultSet,
					columnLabel);

		}

		return resultSet.getResultSetRaw().findColumn(columnLabel);

	}

	@Override
	public java.io.Reader resultSet_getCharacterStream(
			ResultSetProxy resultSet, int columnIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getCharacterStream(this, resultSet,
					columnIndex);

		}

		return resultSet.getResultSetRaw().getCharacterStream(columnIndex);

	}

	@Override
	public java.io.Reader resultSet_getCharacterStream(
			ResultSetProxy resultSet, String columnLabel)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getCharacterStream(this, resultSet,
					columnLabel);

		}

		return resultSet.getResultSetRaw().getCharacterStream(columnLabel);

	}

	@Override
	public BigDecimal resultSet_getBigDecimal(ResultSetProxy resultSet,
			int columnIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getBigDecimal(this, resultSet,
					columnIndex);

		}

		return resultSet.getResultSetRaw().getBigDecimal(columnIndex);

	}

	@Override
	public BigDecimal resultSet_getBigDecimal(ResultSetProxy resultSet,
			String columnLabel) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getBigDecimal(this, resultSet,
					columnLabel);

		}

		return resultSet.getResultSetRaw().getBigDecimal(columnLabel);

	}

	@Override
	public boolean resultSet_isBeforeFirst(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_isBeforeFirst(this, resultSet);

		}

		return resultSet.getResultSetRaw().isBeforeFirst();

	}

	@Override
	public boolean resultSet_isAfterLast(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_isAfterLast(this, resultSet);

		}

		return resultSet.getResultSetRaw().isAfterLast();

	}

	@Override
	public boolean resultSet_isFirst(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_isFirst(this, resultSet);

		}

		return resultSet.getResultSetRaw().isFirst();

	}

	@Override
	public boolean resultSet_isLast(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_isLast(this, resultSet);

		}

		return resultSet.getResultSetRaw().isLast();

	}

	@Override
	public void resultSet_beforeFirst(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_beforeFirst(this, resultSet);

			return;

		}

		resultSet.getResultSetRaw().beforeFirst();

	}

	@Override
	public void resultSet_afterLast(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_afterLast(this, resultSet);

			return;

		}

		resultSet.getResultSetRaw().afterLast();

	}

	@Override
	public boolean resultSet_first(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_first(this, resultSet);

		}

		return resultSet.getResultSetRaw().first();

	}

	@Override
	public boolean resultSet_last(ResultSetProxy resultSet) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_last(this, resultSet);

		}

		return resultSet.getResultSetRaw().last();

	}

	@Override
	public int resultSet_getRow(ResultSetProxy resultSet) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getRow(this, resultSet);

		}

		return resultSet.getResultSetRaw().getRow();

	}

	@Override
	public boolean resultSet_absolute(ResultSetProxy resultSet, int row)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_absolute(this, resultSet, row);

		}

		return resultSet.getResultSetRaw().absolute(row);

	}

	@Override
	public boolean resultSet_relative(ResultSetProxy resultSet, int rows)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_relative(this, resultSet, rows);

		}

		return resultSet.getResultSetRaw().relative(rows);

	}

	@Override
	public boolean resultSet_previous(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_previous(this, resultSet);

		}

		return resultSet.getResultSetRaw().previous();

	}

	@Override
	public void resultSet_setFetchDirection(ResultSetProxy resultSet,
			int direction) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter()
					.resultSet_setFetchDirection(this, resultSet, direction);

			return;

		}

		resultSet.getResultSetRaw().setFetchDirection(direction);

	}

	@Override
	public int resultSet_getFetchDirection(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getFetchDirection(this, resultSet);

		}

		return resultSet.getResultSetRaw().getFetchDirection();

	}

	@Override
	public void resultSet_setFetchSize(ResultSetProxy resultSet, int rows)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_setFetchSize(this, resultSet, rows);

			return;

		}

		resultSet.getResultSetRaw().setFetchSize(rows);

	}

	@Override
	public int resultSet_getFetchSize(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getFetchSize(this, resultSet);

		}

		return resultSet.getResultSetRaw().getFetchSize();

	}

	@Override
	public int resultSet_getType(ResultSetProxy resultSet) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getType(this, resultSet);

		}

		return resultSet.getResultSetRaw().getType();

	}

	@Override
	public int resultSet_getConcurrency(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getConcurrency(this, resultSet);

		}

		return resultSet.getResultSetRaw().getConcurrency();

	}

	@Override
	public boolean resultSet_rowUpdated(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_rowUpdated(this, resultSet);

		}

		return resultSet.getResultSetRaw().rowUpdated();

	}

	@Override
	public boolean resultSet_rowInserted(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_rowInserted(this, resultSet);

		}

		return resultSet.getResultSetRaw().rowInserted();

	}

	@Override
	public boolean resultSet_rowDeleted(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_rowDeleted(this, resultSet);

		}

		return resultSet.getResultSetRaw().rowDeleted();

	}

	@Override
	public void resultSet_updateNull(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNull(this, resultSet, columnIndex);

			return;

		}

		resultSet.getResultSetRaw().updateNull(columnIndex);

	}

	@Override
	public void resultSet_updateBoolean(ResultSetProxy resultSet,
			int columnIndex, boolean x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBoolean(this, resultSet, columnIndex,
					x);

			return;

		}

		resultSet.getResultSetRaw().updateBoolean(columnIndex, x);

	}

	@Override
	public void resultSet_updateByte(ResultSetProxy resultSet, int columnIndex,
			byte x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateByte(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateByte(columnIndex, x);

	}

	@Override
	public void resultSet_updateShort(ResultSetProxy resultSet,
			int columnIndex, short x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateShort(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateShort(columnIndex, x);

	}

	@Override
	public void resultSet_updateInt(ResultSetProxy resultSet, int columnIndex,
			int x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateInt(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateInt(columnIndex, x);

	}

	@Override
	public void resultSet_updateLong(ResultSetProxy resultSet, int columnIndex,
			long x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateLong(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateLong(columnIndex, x);

	}

	@Override
	public void resultSet_updateFloat(ResultSetProxy resultSet,
			int columnIndex, float x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateFloat(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateFloat(columnIndex, x);

	}

	@Override
	public void resultSet_updateDouble(ResultSetProxy resultSet,
			int columnIndex, double x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter()
					.resultSet_updateDouble(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateDouble(columnIndex, x);

	}

	@Override
	public void resultSet_updateBigDecimal(ResultSetProxy resultSet,
			int columnIndex, BigDecimal x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBigDecimal(this, resultSet,
					columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateBigDecimal(columnIndex, x);

	}

	@Override
	public void resultSet_updateString(ResultSetProxy resultSet,
			int columnIndex, String x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter()
					.resultSet_updateString(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateString(columnIndex, x);

	}

	@Override
	public void resultSet_updateBytes(ResultSetProxy resultSet,
			int columnIndex, byte[] x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBytes(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateBytes(columnIndex, x);

	}

	@Override
	public void resultSet_updateDate(ResultSetProxy resultSet, int columnIndex,
			java.sql.Date x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateDate(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateDate(columnIndex, x);

	}

	@Override
	public void resultSet_updateTime(ResultSetProxy resultSet, int columnIndex,
			java.sql.Time x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateTime(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateTime(columnIndex, x);

	}

	@Override
	public void resultSet_updateTimestamp(ResultSetProxy resultSet,
			int columnIndex, java.sql.Timestamp x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateTimestamp(this, resultSet,
					columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateTimestamp(columnIndex, x);

	}

	@Override
	public void resultSet_updateAsciiStream(ResultSetProxy resultSet,
			int columnIndex, java.io.InputStream x, int length)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateAsciiStream(this, resultSet,
					columnIndex, x, length);

			return;

		}

		resultSet.getResultSetRaw().updateAsciiStream(columnIndex, x, length);

	}

	@Override
	public void resultSet_updateBinaryStream(ResultSetProxy resultSet,
			int columnIndex, java.io.InputStream x,

			int length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBinaryStream(this, resultSet,
					columnIndex, x, length);

			return;

		}

		resultSet.getResultSetRaw().updateBinaryStream(columnIndex, x, length);

	}

	@Override
	public void resultSet_updateCharacterStream(ResultSetProxy resultSet,
			int columnIndex, java.io.Reader x, int length)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateCharacterStream(this, resultSet,
					columnIndex, x, length);

			return;

		}

		resultSet.getResultSetRaw().updateCharacterStream(columnIndex, x,
				length);

	}

	@Override
	public void resultSet_updateObject(ResultSetProxy resultSet,
			int columnIndex, Object x, int scaleOrLength)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateObject(this, resultSet, columnIndex,
					x, scaleOrLength);

			return;

		}

		resultSet.getResultSetRaw().updateObject(columnIndex, x, scaleOrLength);

	}

	@Override
	public void resultSet_updateObject(ResultSetProxy resultSet,
			int columnIndex, Object x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter()
					.resultSet_updateObject(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateObject(columnIndex, x);

	}

	@Override
	public void resultSet_updateNull(ResultSetProxy resultSet,
			String columnLabel) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNull(this, resultSet, columnLabel);

			return;

		}

		resultSet.getResultSetRaw().updateNull(columnLabel);

	}

	@Override
	public void resultSet_updateBoolean(ResultSetProxy resultSet,
			String columnLabel, boolean x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBoolean(this, resultSet, columnLabel,
					x);

			return;

		}

		resultSet.getResultSetRaw().updateBoolean(columnLabel, x);

	}

	@Override
	public void resultSet_updateByte(ResultSetProxy resultSet,
			String columnLabel, byte x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateByte(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateByte(columnLabel, x);

	}

	@Override
	public void resultSet_updateShort(ResultSetProxy resultSet,
			String columnLabel, short x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateShort(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateShort(columnLabel, x);

	}

	@Override
	public void resultSet_updateInt(ResultSetProxy resultSet,
			String columnLabel, int x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateInt(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateInt(columnLabel, x);

	}

	@Override
	public void resultSet_updateLong(ResultSetProxy resultSet,
			String columnLabel, long x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateLong(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateLong(columnLabel, x);

	}

	@Override
	public void resultSet_updateFloat(ResultSetProxy resultSet,
			String columnLabel, float x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateFloat(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateFloat(columnLabel, x);

	}

	@Override
	public void resultSet_updateDouble(ResultSetProxy resultSet,
			String columnLabel, double x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter()
					.resultSet_updateDouble(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateDouble(columnLabel, x);

	}

	@Override
	public void resultSet_updateBigDecimal(ResultSetProxy resultSet,
			String columnLabel, BigDecimal x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBigDecimal(this, resultSet,
					columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateBigDecimal(columnLabel, x);

	}

	@Override
	public void resultSet_updateString(ResultSetProxy resultSet,
			String columnLabel, String x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter()
					.resultSet_updateString(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateString(columnLabel, x);

	}

	@Override
	public void resultSet_updateBytes(ResultSetProxy resultSet,
			String columnLabel, byte x[]) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBytes(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateBytes(columnLabel, x);

	}

	@Override
	public void resultSet_updateDate(ResultSetProxy resultSet,
			String columnLabel, java.sql.Date x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateDate(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateDate(columnLabel, x);

	}

	@Override
	public void resultSet_updateTime(ResultSetProxy resultSet,
			String columnLabel, java.sql.Time x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateTime(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateTime(columnLabel, x);

	}

	@Override
	public void resultSet_updateTimestamp(ResultSetProxy resultSet,
			String columnLabel, java.sql.Timestamp x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateTimestamp(this, resultSet,
					columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateTimestamp(columnLabel, x);

	}

	@Override
	public void resultSet_updateAsciiStream(ResultSetProxy resultSet,
			String columnLabel, java.io.InputStream x,

			int length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateAsciiStream(this, resultSet,
					columnLabel, x, length);

			return;

		}

		resultSet.getResultSetRaw().updateAsciiStream(columnLabel, x, length);

	}

	@Override
	public void resultSet_updateBinaryStream(ResultSetProxy resultSet,
			String columnLabel, java.io.InputStream x,

			int length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBinaryStream(this, resultSet,
					columnLabel, x, length);

			return;

		}

		resultSet.getResultSetRaw().updateBinaryStream(columnLabel, x, length);

	}

	@Override
	public void resultSet_updateCharacterStream(ResultSetProxy resultSet,
			String columnLabel, java.io.Reader reader,

			int length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateCharacterStream(this, resultSet,
					columnLabel, reader, length);

			return;

		}

		resultSet.getResultSetRaw().updateCharacterStream(columnLabel, reader,
				length);

	}

	@Override
	public void resultSet_updateObject(ResultSetProxy resultSet,
			String columnLabel, Object x, int scaleOrLength)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateObject(this, resultSet, columnLabel,
					x, scaleOrLength);

			return;

		}

		resultSet.getResultSetRaw().updateObject(columnLabel, x, scaleOrLength);

	}

	@Override
	public void resultSet_updateObject(ResultSetProxy resultSet,
			String columnLabel, Object x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter()
					.resultSet_updateObject(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateObject(columnLabel, x);

	}

	@Override
	public void resultSet_insertRow(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_insertRow(this, resultSet);

			return;

		}

		resultSet.getResultSetRaw().insertRow();

	}

	@Override
	public void resultSet_updateRow(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateRow(this, resultSet);

			return;

		}

		resultSet.getResultSetRaw().updateRow();

	}

	@Override
	public void resultSet_deleteRow(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_deleteRow(this, resultSet);

			return;

		}

		resultSet.getResultSetRaw().deleteRow();

	}

	@Override
	public void resultSet_refreshRow(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_refreshRow(this, resultSet);

			return;

		}

		resultSet.getResultSetRaw().refreshRow();

	}

	@Override
	public void resultSet_cancelRowUpdates(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_cancelRowUpdates(this, resultSet);

			return;

		}

		resultSet.getResultSetRaw().cancelRowUpdates();

	}

	@Override
	public void resultSet_moveToInsertRow(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_moveToInsertRow(this, resultSet);

			return;

		}

		resultSet.getResultSetRaw().moveToInsertRow();

	}

	@Override
	public void resultSet_moveToCurrentRow(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_moveToCurrentRow(this, resultSet);

			return;

		}

		resultSet.getResultSetRaw().moveToCurrentRow();

	}

	@Override
	public Statement resultSet_getStatement(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getStatement(this, resultSet);

		}

		return resultSet.getResultSetRaw().getStatement();

	}

	@Override
	public Object resultSet_getObject(ResultSetProxy resultSet,
			int columnIndex, java.util.Map<String, Class<?>> map)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getObject(this, resultSet,
					columnIndex, map);

		}

		Object obj = resultSet.getResultSetRaw().getObject(columnIndex, map);

		if (obj instanceof ResultSet) {

			return wrap(resultSet.getStatementProxy(), (ResultSet) obj);

		}

		if (obj instanceof Clob) {

			return wrap(resultSet.getStatementProxy(), (Clob) obj);

		}

		return obj;

	}

	@Override
	public Ref resultSet_getRef(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getRef(this, resultSet, columnIndex);

		}

		return resultSet.getResultSetRaw().getRef(columnIndex);

	}

	@Override
	public Blob resultSet_getBlob(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getBlob(this, resultSet, columnIndex);

		}

		return resultSet.getResultSetRaw().getBlob(columnIndex);

	}

	@Override
	public Clob resultSet_getClob(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getClob(this, resultSet, columnIndex);

		}

		Clob clob = resultSet.getResultSetRaw().getClob(columnIndex);

		return wrap(resultSet.getStatementProxy(), clob);

	}

	@Override
	public Array resultSet_getArray(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.resultSet_getArray(this, resultSet, columnIndex);

		}

		Array rawArray = resultSet.getResultSetRaw().getArray(columnIndex);

		return rawArray;

	}

	@Override
	public Object resultSet_getObject(ResultSetProxy resultSet,
			String columnLabel, java.util.Map<String, Class<?>> map)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getObject(this, resultSet,
					columnLabel, map);

		}

		Object obj = resultSet.getResultSetRaw().getObject(columnLabel, map);

		if (obj instanceof ResultSet) {

			return wrap(resultSet.getStatementProxy(), (ResultSet) obj);

		}

		if (obj instanceof Clob) {

			return wrap(resultSet.getStatementProxy(), (Clob) obj);

		}

		return obj;

	}

	@Override
	public Ref resultSet_getRef(ResultSetProxy resultSet, String columnLabel)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getRef(this, resultSet, columnLabel);

		}

		return resultSet.getResultSetRaw().getRef(columnLabel);

	}

	@Override
	public Blob resultSet_getBlob(ResultSetProxy resultSet, String columnLabel)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getBlob(this, resultSet, columnLabel);

		}

		return resultSet.getResultSetRaw().getBlob(columnLabel);

	}

	@Override
	public Clob resultSet_getClob(ResultSetProxy resultSet, String columnLabel)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getClob(this, resultSet, columnLabel);

		}

		Clob clob = resultSet.getResultSetRaw().getClob(columnLabel);

		return wrap(resultSet.getStatementProxy(), clob);

	}

	@Override
	public Array resultSet_getArray(ResultSetProxy resultSet, String columnLabel)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.resultSet_getArray(this, resultSet, columnLabel);

		}

		return resultSet.getResultSetRaw().getArray(columnLabel);

	}

	@Override
	public java.sql.Date resultSet_getDate(ResultSetProxy resultSet,
			int columnIndex, Calendar cal) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getDate(this, resultSet, columnIndex,
					cal);

		}

		return resultSet.getResultSetRaw().getDate(columnIndex, cal);

	}

	@Override
	public java.sql.Date resultSet_getDate(ResultSetProxy resultSet,
			String columnLabel, Calendar cal)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getDate(this, resultSet, columnLabel,
					cal);

		}

		return resultSet.getResultSetRaw().getDate(columnLabel, cal);

	}

	@Override
	public java.sql.Time resultSet_getTime(ResultSetProxy resultSet,
			int columnIndex, Calendar cal) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getTime(this, resultSet, columnIndex,
					cal);

		}

		return resultSet.getResultSetRaw().getTime(columnIndex, cal);

	}

	@Override
	public java.sql.Time resultSet_getTime(ResultSetProxy resultSet,
			String columnLabel, Calendar cal)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getTime(this, resultSet, columnLabel,
					cal);

		}

		return resultSet.getResultSetRaw().getTime(columnLabel, cal);

	}

	@Override
	public java.sql.Timestamp resultSet_getTimestamp(ResultSetProxy resultSet,
			int columnIndex, Calendar cal)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getTimestamp(this, resultSet,
					columnIndex, cal);

		}

		return resultSet.getResultSetRaw().getTimestamp(columnIndex, cal);

	}

	@Override
	public java.sql.Timestamp resultSet_getTimestamp(ResultSetProxy resultSet,
			String columnLabel, Calendar cal)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getTimestamp(this, resultSet,
					columnLabel, cal);

		}

		return resultSet.getResultSetRaw().getTimestamp(columnLabel, cal);

	}

	@Override
	public java.net.URL resultSet_getURL(ResultSetProxy resultSet,
			int columnIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getURL(this, resultSet, columnIndex);

		}

		return resultSet.getResultSetRaw().getURL(columnIndex);

	}

	@Override
	public java.net.URL resultSet_getURL(ResultSetProxy resultSet,
			String columnLabel) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getURL(this, resultSet, columnLabel);

		}

		return resultSet.getResultSetRaw().getURL(columnLabel);

	}

	@Override
	public void resultSet_updateRef(ResultSetProxy resultSet, int columnIndex,
			java.sql.Ref x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateRef(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateRef(columnIndex, x);

	}

	@Override
	public void resultSet_updateRef(ResultSetProxy resultSet,
			String columnLabel, java.sql.Ref x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateRef(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateRef(columnLabel, x);

	}

	@Override
	public void resultSet_updateBlob(ResultSetProxy resultSet, int columnIndex,
			java.sql.Blob x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBlob(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateBlob(columnIndex, x);

	}

	@Override
	public void resultSet_updateBlob(ResultSetProxy resultSet,
			String columnLabel, java.sql.Blob x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBlob(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateBlob(columnLabel, x);

	}

	@Override
	public void resultSet_updateClob(ResultSetProxy resultSet, int columnIndex,
			java.sql.Clob x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateClob(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateClob(columnIndex, x);

	}

	@Override
	public void resultSet_updateClob(ResultSetProxy resultSet,
			String columnLabel, java.sql.Clob x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateClob(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateClob(columnLabel, x);

	}

	@Override
	public void resultSet_updateArray(ResultSetProxy resultSet,
			int columnIndex, java.sql.Array x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateArray(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateArray(columnIndex, x);

	}

	@Override
	public void resultSet_updateArray(ResultSetProxy resultSet,
			String columnLabel, java.sql.Array x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateArray(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateArray(columnLabel, x);

	}

	@Override
	public RowId resultSet_getRowId(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.resultSet_getRowId(this, resultSet, columnIndex);

		}

		return resultSet.getResultSetRaw().getRowId(columnIndex);

	}

	@Override
	public RowId resultSet_getRowId(ResultSetProxy resultSet, String columnLabel)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.resultSet_getRowId(this, resultSet, columnLabel);

		}

		return resultSet.getResultSetRaw().getRowId(columnLabel);

	}

	@Override
	public void resultSet_updateRowId(ResultSetProxy resultSet,
			int columnIndex, RowId x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateRowId(this, resultSet, columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateRowId(columnIndex, x);

	}

	@Override
	public void resultSet_updateRowId(ResultSetProxy resultSet,
			String columnLabel, RowId x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateRowId(this, resultSet, columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateRowId(columnLabel, x);

	}

	@Override
	public int resultSet_getHoldability(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getHoldability(this, resultSet);

		}

		return resultSet.getResultSetRaw().getHoldability();

	}

	@Override
	public boolean resultSet_isClosed(ResultSetProxy resultSet)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_isClosed(this, resultSet);

		}

		return resultSet.getResultSetRaw().isClosed();

	}

	@Override
	public void resultSet_updateNString(ResultSetProxy resultSet,
			int columnIndex, String nString) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNString(this, resultSet, columnIndex,
					nString);

			return;

		}

		resultSet.getResultSetRaw().updateNString(columnIndex, nString);

	}

	@Override
	public void resultSet_updateNString(ResultSetProxy resultSet,
			String columnLabel, String nString)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNString(this, resultSet, columnLabel,
					nString);

			return;

		}

		resultSet.getResultSetRaw().updateNString(columnLabel, nString);

	}

	@Override
	public void resultSet_updateNClob(ResultSetProxy resultSet,
			int columnIndex, NClob nClob) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNClob(this, resultSet, columnIndex,
					nClob);

			return;

		}

		resultSet.getResultSetRaw().updateNClob(columnIndex, nClob);

	}

	@Override
	public void resultSet_updateNClob(ResultSetProxy resultSet,
			String columnLabel, NClob nClob) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNClob(this, resultSet, columnLabel,
					nClob);

			return;

		}

		resultSet.getResultSetRaw().updateNClob(columnLabel, nClob);

	}

	@Override
	public NClob resultSet_getNClob(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.resultSet_getNClob(this, resultSet, columnIndex);

		}

		NClob nclob = resultSet.getResultSetRaw().getNClob(columnIndex);

		return wrap(resultSet.getStatementProxy().getConnectionProxy(), nclob);

	}

	@Override
	public NClob resultSet_getNClob(ResultSetProxy resultSet, String columnLabel)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.resultSet_getNClob(this, resultSet, columnLabel);

		}

		NClob nclob = resultSet.getResultSetRaw().getNClob(columnLabel);

		return wrap(resultSet.getStatementProxy().getConnectionProxy(), nclob);

	}

	@Override
	public SQLXML resultSet_getSQLXML(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getSQLXML(this, resultSet,
					columnIndex);

		}

		return resultSet.getResultSetRaw().getSQLXML(columnIndex);

	}

	@Override
	public SQLXML resultSet_getSQLXML(ResultSetProxy resultSet,
			String columnLabel) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getSQLXML(this, resultSet,
					columnLabel);

		}

		return resultSet.getResultSetRaw().getSQLXML(columnLabel);

	}

	@Override
	public void resultSet_updateSQLXML(ResultSetProxy resultSet,
			int columnIndex, SQLXML xmlObject) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateSQLXML(this, resultSet, columnIndex,
					xmlObject);

			return;

		}

		resultSet.getResultSetRaw().updateSQLXML(columnIndex, xmlObject);

	}

	@Override
	public void resultSet_updateSQLXML(ResultSetProxy resultSet,
			String columnLabel, SQLXML xmlObject)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateSQLXML(this, resultSet, columnLabel,
					xmlObject);

			return;

		}

		resultSet.getResultSetRaw().updateSQLXML(columnLabel, xmlObject);

	}

	@Override
	public String resultSet_getNString(ResultSetProxy resultSet, int columnIndex)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getNString(this, resultSet,
					columnIndex);

		}

		return resultSet.getResultSetRaw().getNString(columnIndex);

	}

	@Override
	public String resultSet_getNString(ResultSetProxy resultSet,
			String columnLabel) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getNString(this, resultSet,
					columnLabel);

		}

		return resultSet.getResultSetRaw().getNString(columnLabel);

	}

	@Override
	public java.io.Reader resultSet_getNCharacterStream(
			ResultSetProxy resultSet, int columnIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getNCharacterStream(this, resultSet,
					columnIndex);

		}

		return resultSet.getResultSetRaw().getNCharacterStream(columnIndex);

	}

	@Override
	public java.io.Reader resultSet_getNCharacterStream(
			ResultSetProxy resultSet, String columnLabel)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSet_getNCharacterStream(this, resultSet,
					columnLabel);

		}

		return resultSet.getResultSetRaw().getNCharacterStream(columnLabel);

	}

	@Override
	public void resultSet_updateNCharacterStream(ResultSetProxy resultSet,
			int columnIndex, java.io.Reader x,

			long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNCharacterStream(this, resultSet,
					columnIndex, x, length);

			return;

		}

		resultSet.getResultSetRaw().updateNCharacterStream(columnIndex, x,
				length);

	}

	@Override
	public void resultSet_updateNCharacterStream(ResultSetProxy resultSet,
			String columnLabel, java.io.Reader reader,

			long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNCharacterStream(this, resultSet,
					columnLabel, reader, length);

			return;

		}

		resultSet.getResultSetRaw().updateNCharacterStream(columnLabel, reader,
				length);

	}

	@Override
	public void resultSet_updateAsciiStream(ResultSetProxy resultSet,
			int columnIndex, java.io.InputStream x,

			long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateAsciiStream(this, resultSet,
					columnIndex, x, length);

			return;

		}

		resultSet.getResultSetRaw().updateAsciiStream(columnIndex, x, length);

	}

	@Override
	public void resultSet_updateBinaryStream(ResultSetProxy resultSet,
			int columnIndex, java.io.InputStream x,

			long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBinaryStream(this, resultSet,
					columnIndex, x, length);

			return;

		}

		resultSet.getResultSetRaw().updateBinaryStream(columnIndex, x, length);

	}

	@Override
	public void resultSet_updateCharacterStream(ResultSetProxy resultSet,
			int columnIndex, java.io.Reader x, long length)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateCharacterStream(this, resultSet,
					columnIndex, x, length);

			return;

		}

		resultSet.getResultSetRaw().updateCharacterStream(columnIndex, x,
				length);

	}

	@Override
	public void resultSet_updateAsciiStream(ResultSetProxy resultSet,
			String columnLabel, java.io.InputStream x,

			long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateAsciiStream(this, resultSet,
					columnLabel, x, length);

			return;

		}

		resultSet.getResultSetRaw().updateAsciiStream(columnLabel, x, length);

	}

	@Override
	public void resultSet_updateBinaryStream(ResultSetProxy resultSet,
			String columnLabel, java.io.InputStream x,

			long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBinaryStream(this, resultSet,
					columnLabel, x, length);

			return;

		}

		resultSet.getResultSetRaw().updateBinaryStream(columnLabel, x, length);

	}

	@Override
	public void resultSet_updateCharacterStream(ResultSetProxy resultSet,
			String columnLabel, java.io.Reader reader,

			long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateCharacterStream(this, resultSet,
					columnLabel, reader, length);

			return;

		}

		resultSet.getResultSetRaw().updateCharacterStream(columnLabel, reader,
				length);

	}

	@Override
	public void resultSet_updateBlob(ResultSetProxy resultSet, int columnIndex,
			InputStream inputStream, long length)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBlob(this, resultSet, columnIndex,
					inputStream, length);

			return;

		}

		resultSet.getResultSetRaw()
				.updateBlob(columnIndex, inputStream, length);

	}

	@Override
	public void resultSet_updateBlob(ResultSetProxy resultSet,
			String columnLabel, InputStream inputStream, long length)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBlob(this, resultSet, columnLabel,
					inputStream, length);

			return;

		}

		resultSet.getResultSetRaw()
				.updateBlob(columnLabel, inputStream, length);

	}

	@Override
	public void resultSet_updateClob(ResultSetProxy resultSet, int columnIndex,
			Reader reader, long length)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateClob(this, resultSet, columnIndex,
					reader, length);

			return;

		}

		resultSet.getResultSetRaw().updateClob(columnIndex, reader, length);

	}

	@Override
	public void resultSet_updateClob(ResultSetProxy resultSet,
			String columnLabel, Reader reader, long length)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateClob(this, resultSet, columnLabel,
					reader, length);

			return;

		}

		resultSet.getResultSetRaw().updateClob(columnLabel, reader, length);

	}

	@Override
	public void resultSet_updateNClob(ResultSetProxy resultSet,
			int columnIndex, Reader reader, long length)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNClob(this, resultSet, columnIndex,
					reader, length);

			return;

		}

		resultSet.getResultSetRaw().updateNClob(columnIndex, reader, length);

	}

	@Override
	public void resultSet_updateNClob(ResultSetProxy resultSet,
			String columnLabel, Reader reader, long length)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNClob(this, resultSet, columnLabel,
					reader, length);

			return;

		}

		resultSet.getResultSetRaw().updateNClob(columnLabel, reader, length);

	}

	@Override
	public void resultSet_updateNCharacterStream(ResultSetProxy resultSet,
			int columnIndex, java.io.Reader x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNCharacterStream(this, resultSet,
					columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateNCharacterStream(columnIndex, x);

	}

	@Override
	public void resultSet_updateNCharacterStream(ResultSetProxy resultSet,
			String columnLabel, java.io.Reader reader)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNCharacterStream(this, resultSet,
					columnLabel, reader);

			return;

		}

		resultSet.getResultSetRaw().updateNCharacterStream(columnLabel, reader);

	}

	@Override
	public void resultSet_updateAsciiStream(ResultSetProxy resultSet,
			int columnIndex, java.io.InputStream x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateAsciiStream(this, resultSet,
					columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateAsciiStream(columnIndex, x);

	}

	@Override
	public void resultSet_updateBinaryStream(ResultSetProxy resultSet,
			int columnIndex, java.io.InputStream x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBinaryStream(this, resultSet,
					columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateBinaryStream(columnIndex, x);

	}

	@Override
	public void resultSet_updateCharacterStream(ResultSetProxy resultSet,
			int columnIndex, java.io.Reader x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateCharacterStream(this, resultSet,
					columnIndex, x);

			return;

		}

		resultSet.getResultSetRaw().updateCharacterStream(columnIndex, x);

	}

	@Override
	public void resultSet_updateAsciiStream(ResultSetProxy resultSet,
			String columnLabel, java.io.InputStream x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateAsciiStream(this, resultSet,
					columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateAsciiStream(columnLabel, x);

	}

	@Override
	public void resultSet_updateBinaryStream(ResultSetProxy resultSet,
			String columnLabel, java.io.InputStream x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBinaryStream(this, resultSet,
					columnLabel, x);

			return;

		}

		resultSet.getResultSetRaw().updateBinaryStream(columnLabel, x);

	}

	@Override
	public void resultSet_updateCharacterStream(ResultSetProxy resultSet,
			String columnLabel, java.io.Reader reader)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateCharacterStream(this, resultSet,
					columnLabel, reader);

			return;

		}

		resultSet.getResultSetRaw().updateCharacterStream(columnLabel, reader);

	}

	@Override
	public void resultSet_updateBlob(ResultSetProxy resultSet, int columnIndex,
			InputStream inputStream)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBlob(this, resultSet, columnIndex,
					inputStream);

			return;

		}

		resultSet.getResultSetRaw().updateBlob(columnIndex, inputStream);

	}

	@Override
	public void resultSet_updateBlob(ResultSetProxy resultSet,
			String columnLabel, InputStream inputStream)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateBlob(this, resultSet, columnLabel,
					inputStream);

			return;

		}

		resultSet.getResultSetRaw().updateBlob(columnLabel, inputStream);

	}

	@Override
	public void resultSet_updateClob(ResultSetProxy resultSet, int columnIndex,
			Reader reader) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateClob(this, resultSet, columnIndex,
					reader);

			return;

		}

		resultSet.getResultSetRaw().updateClob(columnIndex, reader);

	}

	@Override
	public void resultSet_updateClob(ResultSetProxy resultSet,
			String columnLabel, Reader reader) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateClob(this, resultSet, columnLabel,
					reader);

			return;

		}

		resultSet.getResultSetRaw().updateClob(columnLabel, reader);

	}

	@Override
	public void resultSet_updateNClob(ResultSetProxy resultSet,
			int columnIndex, Reader reader) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNClob(this, resultSet, columnIndex,
					reader);

			return;

		}

		resultSet.getResultSetRaw().updateNClob(columnIndex, reader);

	}

	@Override
	public void resultSet_updateNClob(ResultSetProxy resultSet,
			String columnLabel, Reader reader) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().resultSet_updateNClob(this, resultSet, columnLabel,
					reader);

			return;

		}

		resultSet.getResultSetRaw().updateNClob(columnLabel, reader);

	}

	// //////////////////////////////////////// statement

	@Override
	public ResultSetProxy statement_executeQuery(StatementProxy statement,
			String sql) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_executeQuery(this, statement, sql);

		}

		ResultSet resultSet = statement.getRawObject().executeQuery(sql);

		if (resultSet == null) {

			return null;

		}

		return wrap(statement, resultSet);

	}

	@Override
	public int statement_executeUpdate(StatementProxy statement, String sql)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_executeUpdate(this, statement, sql);

		}

		return statement.getRawObject().executeUpdate(sql);

	}

	@Override
	public void statement_close(StatementProxy statement) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().statement_close(this, statement);

			return;

		}

		statement.getRawObject().close();

	}

	@Override
	public int statement_getMaxFieldSize(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getMaxFieldSize(this, statement);

		}

		return statement.getRawObject().getMaxFieldSize();

	}

	@Override
	public void statement_setMaxFieldSize(StatementProxy statement, int max)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().statement_setMaxFieldSize(this, statement, max);

			return;

		}

		statement.getRawObject().setMaxFieldSize(max);

	}

	@Override
	public int statement_getMaxRows(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getMaxRows(this, statement);

		}

		return statement.getRawObject().getMaxRows();

	}

	@Override
	public void statement_setMaxRows(StatementProxy statement, int max)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().statement_setMaxRows(this, statement, max);

			return;

		}

		statement.getRawObject().setMaxRows(max);

	}

	@Override
	public void statement_setEscapeProcessing(StatementProxy statement,
			boolean enable) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().statement_setEscapeProcessing(this, statement, enable);

			return;

		}

		statement.getRawObject().setEscapeProcessing(enable);

	}

	@Override
	public int statement_getQueryTimeout(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getQueryTimeout(this, statement);

		}

		return statement.getRawObject().getQueryTimeout();

	}

	@Override
	public void statement_setQueryTimeout(StatementProxy statement, int seconds)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().statement_setQueryTimeout(this, statement, seconds);

			return;

		}

		statement.getRawObject().setQueryTimeout(seconds);

	}

	@Override
	public void statement_cancel(StatementProxy statement) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().statement_cancel(this, statement);

			return;

		}

		statement.getRawObject().cancel();

	}

	@Override
	public SQLWarning statement_getWarnings(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getWarnings(this, statement);

		}

		return statement.getRawObject().getWarnings();

	}

	@Override
	public void statement_clearWarnings(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().statement_clearWarnings(this, statement);

			return;

		}

		statement.getRawObject().clearWarnings();

	}

	@Override
	public void statement_setCursorName(StatementProxy statement, String name)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().statement_setCursorName(this, statement, name);

			return;

		}

		statement.getRawObject().setCursorName(name);

	}

	@Override
	public boolean statement_execute(StatementProxy statement, String sql)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_execute(this, statement, sql);

		}

		return statement.getRawObject().execute(sql);

	}

	@Override
	public ResultSetProxy statement_getResultSet(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getResultSet(this, statement);

		}

		ResultSet resultSet = statement.getRawObject().getResultSet();

		if (resultSet == null) {

			return null;

		}

		return wrap(statement, resultSet);

	}

	@Override
	public int statement_getUpdateCount(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getUpdateCount(this, statement);

		}

		return statement.getRawObject().getUpdateCount();

	}

	@Override
	public boolean statement_getMoreResults(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getMoreResults(this, statement);

		}

		return statement.getRawObject().getMoreResults();

	}

	@Override
	public void statement_setFetchDirection(StatementProxy statement,
			int direction) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter()
					.statement_setFetchDirection(this, statement, direction);

			return;

		}

		statement.getRawObject().setFetchDirection(direction);

	}

	@Override
	public int statement_getFetchDirection(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getFetchDirection(this, statement);

		}

		return statement.getRawObject().getFetchDirection();

	}

	@Override
	public void statement_setFetchSize(StatementProxy statement, int rows)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().statement_setFetchSize(this, statement, rows);

			return;

		}

		statement.getRawObject().setFetchSize(rows);

	}

	@Override
	public int statement_getFetchSize(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getFetchSize(this, statement);

		}

		return statement.getRawObject().getFetchSize();

	}

	@Override
	public int statement_getResultSetConcurrency(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getResultSetConcurrency(this,
					statement);

		}

		return statement.getRawObject().getResultSetConcurrency();

	}

	@Override
	public int statement_getResultSetType(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getResultSetType(this, statement);

		}

		return statement.getRawObject().getResultSetType();

	}

	@Override
	public void statement_addBatch(StatementProxy statement, String sql)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().statement_addBatch(this, statement, sql);

			return;

		}

		statement.getRawObject().addBatch(sql);

	}

	@Override
	public void statement_clearBatch(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().statement_clearBatch(this, statement);

			return;

		}

		statement.getRawObject().clearBatch();

	}

	@Override
	public int[] statement_executeBatch(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_executeBatch(this, statement);

		}

		return statement.getRawObject().executeBatch();

	}

	@Override
	public Connection statement_getConnection(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getConnection(this, statement);

		}

		return statement.getRawObject().getConnection();

	}

	@Override
	public boolean statement_getMoreResults(StatementProxy statement,
			int current) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getMoreResults(this, statement,
					current);

		}

		return statement.getRawObject().getMoreResults(current);

	}

	@Override
	public ResultSetProxy statement_getGeneratedKeys(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getGeneratedKeys(this, statement);

		}

		ResultSet resultSet = statement.getRawObject().getGeneratedKeys();

		return wrap(statement, resultSet);

	}

	@Override
	public int statement_executeUpdate(StatementProxy statement, String sql,
			int autoGeneratedKeys) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_executeUpdate(this, statement, sql,
					autoGeneratedKeys);

		}

		return statement.getRawObject().executeUpdate(sql, autoGeneratedKeys);

	}

	@Override
	public int statement_executeUpdate(StatementProxy statement, String sql,
			int columnIndexes[]) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_executeUpdate(this, statement, sql,
					columnIndexes);

		}

		return statement.getRawObject().executeUpdate(sql, columnIndexes);

	}

	@Override
	public int statement_executeUpdate(StatementProxy statement, String sql,
			String columnNames[]) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_executeUpdate(this, statement, sql,
					columnNames);

		}

		return statement.getRawObject().executeUpdate(sql, columnNames);

	}

	@Override
	public boolean statement_execute(StatementProxy statement, String sql,
			int autoGeneratedKeys) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_execute(this, statement, sql,
					autoGeneratedKeys);

		}

		return statement.getRawObject().execute(sql, autoGeneratedKeys);

	}

	@Override
	public boolean statement_execute(StatementProxy statement, String sql,
			int columnIndexes[]) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_execute(this, statement, sql,
					columnIndexes);

		}

		return statement.getRawObject().execute(sql, columnIndexes);

	}

	@Override
	public boolean statement_execute(StatementProxy statement, String sql,
			String columnNames[]) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_execute(this, statement, sql,
					columnNames);

		}

		return statement.getRawObject().execute(sql, columnNames);

	}

	@Override
	public int statement_getResultSetHoldability(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_getResultSetHoldability(this,
					statement);

		}

		return statement.getRawObject().getResultSetHoldability();

	}

	@Override
	public boolean statement_isClosed(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_isClosed(this, statement);

		}

		return statement.getRawObject().isClosed();

	}

	@Override
	public void statement_setPoolable(StatementProxy statement, boolean poolable)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().statement_setPoolable(this, statement, poolable);

			return;

		}

		statement.getRawObject().setPoolable(poolable);

	}

	@Override
	public boolean statement_isPoolable(StatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().statement_isPoolable(this, statement);

		}

		return statement.getRawObject().isPoolable();

	}

	// ////////////////

	@Override
	public ResultSetProxy preparedStatement_executeQuery(
			PreparedStatementProxy statement) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().preparedStatement_executeQuery(this, statement);

		}

		ResultSet resultSet = statement.getRawObject().executeQuery();

		return wrap(statement, resultSet);

	}

	@Override
	public int preparedStatement_executeUpdate(PreparedStatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.preparedStatement_executeUpdate(this, statement);

		}

		return statement.getRawObject().executeUpdate();

	}

	@Override
	public void preparedStatement_setNull(PreparedStatementProxy statement,
			int parameterIndex, int sqlType)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setNull(this, statement,
					parameterIndex, sqlType);

			return;

		}

		statement.getRawObject().setNull(parameterIndex, sqlType);

	}

	@Override
	public void preparedStatement_setBoolean(PreparedStatementProxy statement,
			int parameterIndex, boolean x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setBoolean(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setBoolean(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setByte(PreparedStatementProxy statement,
			int parameterIndex, byte x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setByte(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setByte(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setShort(PreparedStatementProxy statement,
			int parameterIndex, short x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setShort(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setShort(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setInt(PreparedStatementProxy statement,
			int parameterIndex, int x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setInt(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setInt(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setLong(PreparedStatementProxy statement,
			int parameterIndex, long x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setLong(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setLong(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setFloat(PreparedStatementProxy statement,
			int parameterIndex, float x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setFloat(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setFloat(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setDouble(PreparedStatementProxy statement,
			int parameterIndex, double x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setDouble(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setDouble(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setBigDecimal(
			PreparedStatementProxy statement, int parameterIndex, BigDecimal x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setBigDecimal(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setBigDecimal(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setString(PreparedStatementProxy statement,
			int parameterIndex, String x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setString(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setString(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setBytes(PreparedStatementProxy statement,
			int parameterIndex, byte x[])

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setBytes(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setBytes(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setDate(PreparedStatementProxy statement,
			int parameterIndex, java.sql.Date x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setDate(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setDate(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setTime(PreparedStatementProxy statement,
			int parameterIndex, java.sql.Time x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setTime(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setTime(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setTimestamp(
			PreparedStatementProxy statement, int parameterIndex,

			java.sql.Timestamp x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setTimestamp(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setTimestamp(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setAsciiStream(
			PreparedStatementProxy statement, int parameterIndex,

			java.io.InputStream x, int length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setAsciiStream(this, statement,
					parameterIndex, x, length);

			return;

		}

		statement.getRawObject().setAsciiStream(parameterIndex, x, length);

	}

	@SuppressWarnings("deprecation")
	@Override
	public void preparedStatement_setUnicodeStream(
			PreparedStatementProxy statement, int parameterIndex,

			java.io.InputStream x, int length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setUnicodeStream(this, statement,
					parameterIndex, x, length);

			return;

		}

		statement.getRawObject().setUnicodeStream(parameterIndex, x, length);

	}

	@Override
	public void preparedStatement_setBinaryStream(
			PreparedStatementProxy statement, int parameterIndex,

			java.io.InputStream x, int length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setBinaryStream(this, statement,
					parameterIndex, x, length);

			return;

		}

		statement.getRawObject().setBinaryStream(parameterIndex, x, length);

	}

	@Override
	public void preparedStatement_clearParameters(
			PreparedStatementProxy statement) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_clearParameters(this, statement);

			return;

		}

		statement.getRawObject().clearParameters();

	}

	@Override
	public void preparedStatement_setObject(PreparedStatementProxy statement,
			int parameterIndex, Object x,

			int targetSqlType) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setObject(this, statement,
					parameterIndex, x, targetSqlType);

			return;

		}

		statement.getRawObject().setObject(parameterIndex, x, targetSqlType);

	}

	@Override
	public void preparedStatement_setObject(PreparedStatementProxy statement,
			int parameterIndex, Object x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setObject(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setObject(parameterIndex, x);

	}

	@Override
	public boolean preparedStatement_execute(PreparedStatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().preparedStatement_execute(this, statement);

		}

		return statement.getRawObject().execute();

	}

	@Override
	public void preparedStatement_addBatch(PreparedStatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_addBatch(this, statement);

			return;

		}

		statement.getRawObject().addBatch();

	}

	@Override
	public void preparedStatement_setCharacterStream(
			PreparedStatementProxy statement, int parameterIndex,

			java.io.Reader reader, int length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setCharacterStream(this, statement,
					parameterIndex, reader, length);

			return;

		}

		statement.getRawObject().setCharacterStream(parameterIndex, reader,
				length);

	}

	@Override
	public void preparedStatement_setRef(PreparedStatementProxy statement,
			int parameterIndex, Ref x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setRef(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setRef(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setBlob(PreparedStatementProxy statement,
			int parameterIndex, Blob x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setBlob(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setBlob(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setClob(PreparedStatementProxy statement,
			int parameterIndex, Clob x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setClob(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setClob(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setArray(PreparedStatementProxy statement,
			int parameterIndex, Array x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setArray(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setArray(parameterIndex, x);

	}

	@Override
	public ResultSetMetaData preparedStatement_getMetaData(
			PreparedStatementProxy statement) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().preparedStatement_getMetaData(this, statement);

		}

		return statement.getRawObject().getMetaData();

	}

	@Override
	public void preparedStatement_setDate(PreparedStatementProxy statement,
			int parameterIndex, java.sql.Date x,

			Calendar cal) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setDate(this, statement,
					parameterIndex, x, cal);

			return;

		}

		statement.getRawObject().setDate(parameterIndex, x, cal);

	}

	@Override
	public void preparedStatement_setTime(PreparedStatementProxy statement,
			int parameterIndex, java.sql.Time x,

			Calendar cal) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setTime(this, statement,
					parameterIndex, x, cal);

			return;

		}

		statement.getRawObject().setTime(parameterIndex, x, cal);

	}

	@Override
	public void preparedStatement_setTimestamp(
			PreparedStatementProxy statement, int parameterIndex,

			java.sql.Timestamp x, Calendar cal) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setTimestamp(this, statement,
					parameterIndex, x, cal);

			return;

		}

		statement.getRawObject().setTimestamp(parameterIndex, x, cal);

	}

	@Override
	public void preparedStatement_setNull(PreparedStatementProxy statement,
			int parameterIndex, int sqlType,

			String typeName) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setNull(this, statement,
					parameterIndex, sqlType, typeName);

			return;

		}

		statement.getRawObject().setNull(parameterIndex, sqlType, typeName);

	}

	@Override
	public void preparedStatement_setURL(PreparedStatementProxy statement,
			int parameterIndex, java.net.URL x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setURL(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setURL(parameterIndex, x);

	}

	@Override
	public ParameterMetaData preparedStatement_getParameterMetaData(
			PreparedStatementProxy statement)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().preparedStatement_getParameterMetaData(this,
					statement);

		}

		return statement.getRawObject().getParameterMetaData();

	}

	@Override
	public void preparedStatement_setRowId(PreparedStatementProxy statement,
			int parameterIndex, RowId x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setRowId(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setRowId(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setNString(PreparedStatementProxy statement,
			int parameterIndex, String value)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setNString(this, statement,
					parameterIndex, value);

			return;

		}

		statement.getRawObject().setNString(parameterIndex, value);

	}

	@Override
	public void preparedStatement_setNCharacterStream(
			PreparedStatementProxy statement, int parameterIndex,

			Reader value, long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setNCharacterStream(this, statement,
					parameterIndex, value, length);

			return;

		}

		statement.getRawObject().setNCharacterStream(parameterIndex, value,
				length);

	}

	@Override
	public void preparedStatement_setNClob(PreparedStatementProxy statement,
			int parameterIndex, NClob value)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setNClob(this, statement,
					parameterIndex, value);

			return;

		}

		statement.getRawObject().setNClob(parameterIndex, value);

	}

	@Override
	public void preparedStatement_setClob(PreparedStatementProxy statement,
			int parameterIndex, Reader reader,

			long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setClob(this, statement,
					parameterIndex, reader, length);

			return;

		}

		statement.getRawObject().setClob(parameterIndex, reader, length);

	}

	@Override
	public void preparedStatement_setBlob(PreparedStatementProxy statement,
			int parameterIndex,

			InputStream inputStream, long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setBlob(this, statement,
					parameterIndex, inputStream, length);

			return;

		}

		statement.getRawObject().setBlob(parameterIndex, inputStream, length);

	}

	@Override
	public void preparedStatement_setNClob(PreparedStatementProxy statement,
			int parameterIndex, Reader reader,

			long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setNClob(this, statement,
					parameterIndex, reader, length);

			return;

		}

		statement.getRawObject().setNClob(parameterIndex, reader, length);

	}

	@Override
	public void preparedStatement_setSQLXML(PreparedStatementProxy statement,
			int parameterIndex, SQLXML xmlObject)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setSQLXML(this, statement,
					parameterIndex, xmlObject);

			return;

		}

		statement.getRawObject().setSQLXML(parameterIndex, xmlObject);

	}

	@Override
	public void preparedStatement_setObject(PreparedStatementProxy statement,
			int parameterIndex, Object x,

			int targetSqlType, int scaleOrLength) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setObject(this, statement,
					parameterIndex, x, targetSqlType, scaleOrLength);

			return;

		}

		statement.getRawObject().setObject(parameterIndex, x, targetSqlType,
				scaleOrLength);

	}

	@Override
	public void preparedStatement_setAsciiStream(
			PreparedStatementProxy statement, int parameterIndex,

			java.io.InputStream x, long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setAsciiStream(this, statement,
					parameterIndex, x, length);

			return;

		}

		statement.getRawObject().setAsciiStream(parameterIndex, x, length);

	}

	@Override
	public void preparedStatement_setBinaryStream(
			PreparedStatementProxy statement, int parameterIndex,

			java.io.InputStream x, long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setBinaryStream(this, statement,
					parameterIndex, x, length);

			return;

		}

		statement.getRawObject().setBinaryStream(parameterIndex, x, length);

	}

	@Override
	public void preparedStatement_setCharacterStream(
			PreparedStatementProxy statement, int parameterIndex,

			java.io.Reader reader, long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setCharacterStream(this, statement,
					parameterIndex, reader, length);

			return;

		}

		statement.getRawObject().setCharacterStream(parameterIndex, reader,
				length);

	}

	@Override
	public void preparedStatement_setAsciiStream(
			PreparedStatementProxy statement, int parameterIndex,

			java.io.InputStream x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setAsciiStream(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setAsciiStream(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setBinaryStream(
			PreparedStatementProxy statement, int parameterIndex,

			java.io.InputStream x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setBinaryStream(this, statement,
					parameterIndex, x);

			return;

		}

		statement.getRawObject().setBinaryStream(parameterIndex, x);

	}

	@Override
	public void preparedStatement_setCharacterStream(
			PreparedStatementProxy statement, int parameterIndex,

			java.io.Reader reader) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setCharacterStream(this, statement,
					parameterIndex, reader);

			return;

		}

		statement.getRawObject().setCharacterStream(parameterIndex, reader);

	}

	@Override
	public void preparedStatement_setNCharacterStream(
			PreparedStatementProxy statement, int parameterIndex, Reader value)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setNCharacterStream(this, statement,
					parameterIndex, value);

			return;

		}

		statement.getRawObject().setNCharacterStream(parameterIndex, value);

	}

	@Override
	public void preparedStatement_setClob(PreparedStatementProxy statement,
			int parameterIndex, Reader reader)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setClob(this, statement,
					parameterIndex, reader);

			return;

		}

		statement.getRawObject().setClob(parameterIndex, reader);

	}

	@Override
	public void preparedStatement_setBlob(PreparedStatementProxy statement,
			int parameterIndex, InputStream inputStream)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setBlob(this, statement,
					parameterIndex, inputStream);

			return;

		}

		statement.getRawObject().setBlob(parameterIndex, inputStream);

	}

	@Override
	public void preparedStatement_setNClob(PreparedStatementProxy statement,
			int parameterIndex, Reader reader)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().preparedStatement_setNClob(this, statement,
					parameterIndex, reader);

			return;

		}

		statement.getRawObject().setNClob(parameterIndex, reader);

	}

	// /////////////////////////////////////

	@Override
	public void callableStatement_registerOutParameter(
			CallableStatementProxy statement, int parameterIndex, int sqlType)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_registerOutParameter(this,
					statement, parameterIndex, sqlType);

			return;

		}

		statement.getRawObject().registerOutParameter(parameterIndex, sqlType);

	}

	@Override
	public void callableStatement_registerOutParameter(
			CallableStatementProxy statement, int parameterIndex,

			int sqlType, int scale) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_registerOutParameter(this,
					statement, parameterIndex, sqlType, scale);

			return;

		}

		statement.getRawObject().registerOutParameter(parameterIndex, sqlType,
				scale);

	}

	@Override
	public boolean callableStatement_wasNull(CallableStatementProxy statement)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_wasNull(this, statement);

		}

		return statement.getRawObject().wasNull();

	}

	@Override
	public String callableStatement_getString(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getString(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getString(parameterIndex);

	}

	@Override
	public boolean callableStatement_getBoolean(
			CallableStatementProxy statement, int parameterIndex)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getBoolean(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getBoolean(parameterIndex);

	}

	@Override
	public byte callableStatement_getByte(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getByte(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getByte(parameterIndex);

	}

	@Override
	public short callableStatement_getShort(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getShort(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getShort(parameterIndex);

	}

	@Override
	public int callableStatement_getInt(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getInt(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getInt(parameterIndex);

	}

	@Override
	public long callableStatement_getLong(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getLong(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getLong(parameterIndex);

	}

	@Override
	public float callableStatement_getFloat(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getFloat(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getFloat(parameterIndex);

	}

	@Override
	public double callableStatement_getDouble(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getDouble(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getDouble(parameterIndex);

	}

	@SuppressWarnings("deprecation")
	@Override
	public BigDecimal callableStatement_getBigDecimal(
			CallableStatementProxy statement, int parameterIndex, int scale)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getBigDecimal(this,
					statement, parameterIndex, scale);

		}

		return statement.getRawObject().getBigDecimal(parameterIndex, scale);

	}

	@Override
	public byte[] callableStatement_getBytes(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getBytes(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getBytes(parameterIndex);

	}

	@Override
	public java.sql.Date callableStatement_getDate(
			CallableStatementProxy statement, int parameterIndex)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getDate(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getDate(parameterIndex);

	}

	@Override
	public java.sql.Time callableStatement_getTime(
			CallableStatementProxy statement, int parameterIndex)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getTime(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getTime(parameterIndex);

	}

	@Override
	public java.sql.Timestamp callableStatement_getTimestamp(
			CallableStatementProxy statement, int parameterIndex)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getTimestamp(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getTimestamp(parameterIndex);

	}

	@Override
	public Object callableStatement_getObject(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getObject(this, statement,
					parameterIndex);

		}

		Object obj = statement.getRawObject().getObject(parameterIndex);

		if (obj instanceof ResultSet) {

			return wrap(statement, (ResultSet) obj);

		}

		if (obj instanceof Clob) {

			return wrap(statement, (Clob) obj);

		}

		return obj;

	}

	@Override
	public Object callableStatement_getObject(CallableStatementProxy statement,
			int parameterIndex,

			java.util.Map<String, Class<?>> map) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getObject(this, statement,
					parameterIndex, map);

		}

		Object obj = statement.getRawObject().getObject(parameterIndex, map);

		if (obj instanceof ResultSet) {

			return wrap(statement, (ResultSet) obj);

		}

		if (obj instanceof Clob) {

			return wrap(statement, (Clob) obj);

		}

		return obj;

	}

	@Override
	public Object callableStatement_getObject(CallableStatementProxy statement,
			String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getObject(this, statement,
					parameterName);

		}

		Object obj = statement.getRawObject().getObject(parameterName);

		if (obj instanceof ResultSet) {

			return wrap(statement, (ResultSet) obj);

		}

		if (obj instanceof Clob) {

			return wrap(statement, (Clob) obj);

		}

		return obj;

	}

	@Override
	public Object callableStatement_getObject(CallableStatementProxy statement,
			String parameterName,

			java.util.Map<String, Class<?>> map) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getObject(this, statement,
					parameterName, map);

		}

		Object obj = statement.getRawObject().getObject(parameterName, map);

		if (obj instanceof ResultSet) {

			return wrap(statement, (ResultSet) obj);

		}

		if (obj instanceof Clob) {

			return wrap(statement, (Clob) obj);

		}

		return obj;

	}

	@Override
	public BigDecimal callableStatement_getBigDecimal(
			CallableStatementProxy statement, int parameterIndex)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getBigDecimal(this,
					statement, parameterIndex);

		}

		return statement.getRawObject().getBigDecimal(parameterIndex);

	}

	@Override
	public Ref callableStatement_getRef(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getRef(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getRef(parameterIndex);

	}

	@Override
	public Blob callableStatement_getBlob(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getBlob(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getBlob(parameterIndex);

	}

	@Override
	public Clob callableStatement_getClob(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getClob(this, statement,
					parameterIndex);

		}

		Clob clob = statement.getRawObject().getClob(parameterIndex);

		return wrap(statement, clob);

	}

	@Override
	public Array callableStatement_getArray(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getArray(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getArray(parameterIndex);

	}

	@Override
	public java.sql.Date callableStatement_getDate(
			CallableStatementProxy statement, int parameterIndex, Calendar cal)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getDate(this, statement,
					parameterIndex, cal);

		}

		return statement.getRawObject().getDate(parameterIndex, cal);

	}

	@Override
	public java.sql.Time callableStatement_getTime(
			CallableStatementProxy statement, int parameterIndex, Calendar cal)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getTime(this, statement,
					parameterIndex, cal);

		}

		return statement.getRawObject().getTime(parameterIndex, cal);

	}

	@Override
	public java.sql.Timestamp callableStatement_getTimestamp(
			CallableStatementProxy statement, int parameterIndex,

			Calendar cal) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getTimestamp(this, statement,
					parameterIndex, cal);

		}

		return statement.getRawObject().getTimestamp(parameterIndex, cal);

	}

	@Override
	public void callableStatement_registerOutParameter(
			CallableStatementProxy statement, int parameterIndex,

			int sqlType, String typeName) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_registerOutParameter(this,
					statement, parameterIndex, sqlType, typeName);

			return;

		}

		statement.getRawObject().registerOutParameter(parameterIndex, sqlType,
				typeName);

	}

	@Override
	public void callableStatement_registerOutParameter(
			CallableStatementProxy statement, String parameterName,

			int sqlType) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_registerOutParameter(this,
					statement, parameterName, sqlType);

			return;

		}

		statement.getRawObject().registerOutParameter(parameterName, sqlType);

	}

	@Override
	public void callableStatement_registerOutParameter(
			CallableStatementProxy statement, String parameterName,

			int sqlType, int scale) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_registerOutParameter(this,
					statement, parameterName, sqlType, scale);

			return;

		}

		statement.getRawObject().registerOutParameter(parameterName, sqlType,
				scale);

	}

	@Override
	public void callableStatement_registerOutParameter(
			CallableStatementProxy statement, String parameterName,

			int sqlType, String typeName) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_registerOutParameter(this,
					statement, parameterName, sqlType, typeName);

			return;

		}

		statement.getRawObject().registerOutParameter(parameterName, sqlType,
				typeName);

	}

	@Override
	public java.net.URL callableStatement_getURL(
			CallableStatementProxy statement, int parameterIndex)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getURL(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getURL(parameterIndex);

	}

	@Override
	public void callableStatement_setURL(CallableStatementProxy statement,
			String parameterName, java.net.URL val)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setURL(this, statement,
					parameterName, val);

			return;

		}

		statement.getRawObject().setURL(parameterName, val);

	}

	@Override
	public void callableStatement_setNull(CallableStatementProxy statement,
			String parameterName, int sqlType)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setNull(this, statement,
					parameterName, sqlType);

			return;

		}

		statement.getRawObject().setNull(parameterName, sqlType);

	}

	@Override
	public void callableStatement_setBoolean(CallableStatementProxy statement,
			String parameterName, boolean x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setBoolean(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setBoolean(parameterName, x);

	}

	@Override
	public void callableStatement_setByte(CallableStatementProxy statement,
			String parameterName, byte x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setByte(this, statement,
					parameterName, x);

		}

		statement.getRawObject().setByte(parameterName, x);

	}

	@Override
	public void callableStatement_setShort(CallableStatementProxy statement,
			String parameterName, short x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setShort(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setShort(parameterName, x);

	}

	@Override
	public void callableStatement_setInt(CallableStatementProxy statement,
			String parameterName, int x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setInt(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setInt(parameterName, x);

	}

	@Override
	public void callableStatement_setLong(CallableStatementProxy statement,
			String parameterName, long x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setLong(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setLong(parameterName, x);

	}

	@Override
	public void callableStatement_setFloat(CallableStatementProxy statement,
			String parameterName, float x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setFloat(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setFloat(parameterName, x);

	}

	@Override
	public void callableStatement_setDouble(CallableStatementProxy statement,
			String parameterName, double x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setDouble(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setDouble(parameterName, x);

	}

	@Override
	public void callableStatement_setBigDecimal(
			CallableStatementProxy statement, String parameterName, BigDecimal x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setBigDecimal(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setBigDecimal(parameterName, x);

	}

	@Override
	public void callableStatement_setString(CallableStatementProxy statement,
			String parameterName, String x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setString(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setString(parameterName, x);

	}

	@Override
	public void callableStatement_setBytes(CallableStatementProxy statement,
			String parameterName, byte x[])

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setBytes(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setBytes(parameterName, x);

	}

	@Override
	public void callableStatement_setDate(CallableStatementProxy statement,
			String parameterName, java.sql.Date x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setDate(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setDate(parameterName, x);

	}

	@Override
	public void callableStatement_setTime(CallableStatementProxy statement,
			String parameterName, java.sql.Time x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setTime(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setTime(parameterName, x);

	}

	@Override
	public void callableStatement_setTimestamp(
			CallableStatementProxy statement, String parameterName,

			java.sql.Timestamp x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setTimestamp(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setTimestamp(parameterName, x);

	}

	@Override
	public void callableStatement_setAsciiStream(
			CallableStatementProxy statement, String parameterName,

			java.io.InputStream x, int length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setAsciiStream(this, statement,
					parameterName, x, length);

			return;

		}

		statement.getRawObject().setAsciiStream(parameterName, x, length);

	}

	@Override
	public void callableStatement_setBinaryStream(
			CallableStatementProxy statement, String parameterName,

			java.io.InputStream x, int length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setBinaryStream(this, statement,
					parameterName, x, length);

			return;

		}

		statement.getRawObject().setBinaryStream(parameterName, x, length);

	}

	@Override
	public void callableStatement_setObject(CallableStatementProxy statement,
			String parameterName, Object x,

			int targetSqlType, int scale) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setObject(this, statement,
					parameterName, x, targetSqlType, scale);

			return;

		}

		statement.getRawObject().setObject(parameterName, x, targetSqlType,
				scale);

	}

	@Override
	public void callableStatement_setObject(CallableStatementProxy statement,
			String parameterName, Object x,

			int targetSqlType) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setObject(this, statement,
					parameterName, x, targetSqlType);

			return;

		}

		statement.getRawObject().setObject(parameterName, x, targetSqlType);

	}

	@Override
	public void callableStatement_setObject(CallableStatementProxy statement,
			String parameterName, Object x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setObject(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setObject(parameterName, x);

	}

	@Override
	public void callableStatement_setCharacterStream(
			CallableStatementProxy statement, String parameterName,

			java.io.Reader reader, int length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setCharacterStream(this, statement,
					parameterName, reader, length);

			return;

		}

		statement.getRawObject().setCharacterStream(parameterName, reader,
				length);

	}

	@Override
	public void callableStatement_setDate(CallableStatementProxy statement,
			String parameterName, java.sql.Date x,

			Calendar cal) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setDate(this, statement,
					parameterName, x, cal);

			return;

		}

		statement.getRawObject().setDate(parameterName, x, cal);

	}

	@Override
	public void callableStatement_setTime(CallableStatementProxy statement,
			String parameterName, java.sql.Time x,

			Calendar cal) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setTime(this, statement,
					parameterName, x, cal);

			return;

		}

		statement.getRawObject().setTime(parameterName, x, cal);

	}

	@Override
	public void callableStatement_setTimestamp(
			CallableStatementProxy statement, String parameterName,

			java.sql.Timestamp x, Calendar cal) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setTimestamp(this, statement,
					parameterName, x, cal);

			return;

		}

		statement.getRawObject().setTimestamp(parameterName, x, cal);

	}

	@Override
	public void callableStatement_setNull(CallableStatementProxy statement,
			String parameterName, int sqlType,

			String typeName) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setNull(this, statement,
					parameterName, sqlType, typeName);

			return;

		}

		statement.getRawObject().setNull(parameterName, sqlType, typeName);

	}

	@Override
	public String callableStatement_getString(CallableStatementProxy statement,
			String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getString(this, statement,
					parameterName);

		}

		return statement.getRawObject().getString(parameterName);

	}

	@Override
	public boolean callableStatement_getBoolean(
			CallableStatementProxy statement, String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getBoolean(this, statement,
					parameterName);

		}

		return statement.getRawObject().getBoolean(parameterName);

	}

	@Override
	public byte callableStatement_getByte(CallableStatementProxy statement,
			String parameterName) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getByte(this, statement,
					parameterName);

		}

		return statement.getRawObject().getByte(parameterName);

	}

	@Override
	public short callableStatement_getShort(CallableStatementProxy statement,
			String parameterName) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getShort(this, statement,
					parameterName);

		}

		return statement.getRawObject().getShort(parameterName);

	}

	@Override
	public int callableStatement_getInt(CallableStatementProxy statement,
			String parameterName) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getInt(this, statement,
					parameterName);

		}

		return statement.getRawObject().getInt(parameterName);

	}

	@Override
	public long callableStatement_getLong(CallableStatementProxy statement,
			String parameterName) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getLong(this, statement,
					parameterName);

		}

		return statement.getRawObject().getLong(parameterName);

	}

	@Override
	public float callableStatement_getFloat(CallableStatementProxy statement,
			String parameterName) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getFloat(this, statement,
					parameterName);

		}

		return statement.getRawObject().getFloat(parameterName);

	}

	@Override
	public double callableStatement_getDouble(CallableStatementProxy statement,
			String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getDouble(this, statement,
					parameterName);

		}

		return statement.getRawObject().getDouble(parameterName);

	}

	@Override
	public byte[] callableStatement_getBytes(CallableStatementProxy statement,
			String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getBytes(this, statement,
					parameterName);

		}

		return statement.getRawObject().getBytes(parameterName);

	}

	@Override
	public java.sql.Date callableStatement_getDate(
			CallableStatementProxy statement, String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getDate(this, statement,
					parameterName);

		}

		return statement.getRawObject().getDate(parameterName);

	}

	@Override
	public java.sql.Time callableStatement_getTime(
			CallableStatementProxy statement, String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getTime(this, statement,
					parameterName);

		}

		return statement.getRawObject().getTime(parameterName);

	}

	@Override
	public java.sql.Timestamp callableStatement_getTimestamp(
			CallableStatementProxy statement, String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getTimestamp(this, statement,
					parameterName);

		}

		return statement.getRawObject().getTimestamp(parameterName);

	}

	@Override
	public BigDecimal callableStatement_getBigDecimal(
			CallableStatementProxy statement, String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getBigDecimal(this,
					statement, parameterName);

		}

		return statement.getRawObject().getBigDecimal(parameterName);

	}

	@Override
	public Ref callableStatement_getRef(CallableStatementProxy statement,
			String parameterName) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getRef(this, statement,
					parameterName);

		}

		return statement.getRawObject().getRef(parameterName);

	}

	@Override
	public Blob callableStatement_getBlob(CallableStatementProxy statement,
			String parameterName) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getBlob(this, statement,
					parameterName);

		}

		return statement.getRawObject().getBlob(parameterName);

	}

	@Override
	public Clob callableStatement_getClob(CallableStatementProxy statement,
			String parameterName) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getClob(this, statement,
					parameterName);

		}

		Clob clob = statement.getRawObject().getClob(parameterName);

		return wrap(statement, clob);

	}

	@Override
	public Array callableStatement_getArray(CallableStatementProxy statement,
			String parameterName) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getArray(this, statement,
					parameterName);

		}

		return statement.getRawObject().getArray(parameterName);

	}

	@Override
	public java.sql.Date callableStatement_getDate(
			CallableStatementProxy statement, String parameterName, Calendar cal)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getDate(this, statement,
					parameterName, cal);

		}

		return statement.getRawObject().getDate(parameterName, cal);

	}

	@Override
	public java.sql.Time callableStatement_getTime(
			CallableStatementProxy statement, String parameterName, Calendar cal)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getTime(this, statement,
					parameterName, cal);

		}

		return statement.getRawObject().getTime(parameterName, cal);

	}

	@Override
	public java.sql.Timestamp callableStatement_getTimestamp(
			CallableStatementProxy statement, String parameterName,

			Calendar cal) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getTimestamp(this, statement,
					parameterName, cal);

		}

		return statement.getRawObject().getTimestamp(parameterName, cal);

	}

	@Override
	public java.net.URL callableStatement_getURL(
			CallableStatementProxy statement, String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getURL(this, statement,
					parameterName);

		}

		return statement.getRawObject().getURL(parameterName);

	}

	@Override
	public RowId callableStatement_getRowId(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getRowId(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getRowId(parameterIndex);

	}

	@Override
	public RowId callableStatement_getRowId(CallableStatementProxy statement,
			String parameterName) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getRowId(this, statement,
					parameterName);

		}

		return statement.getRawObject().getRowId(parameterName);

	}

	@Override
	public void callableStatement_setRowId(CallableStatementProxy statement,
			String parameterName, RowId x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setRowId(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setRowId(parameterName, x);

	}

	@Override
	public void callableStatement_setNString(CallableStatementProxy statement,
			String parameterName, String value)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setNString(this, statement,
					parameterName, value);

			return;

		}

		statement.getRawObject().setNString(parameterName, value);

	}

	@Override
	public void callableStatement_setNCharacterStream(
			CallableStatementProxy statement, String parameterName,

			Reader value, long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setNCharacterStream(this, statement,
					parameterName, value, length);

			return;

		}

		statement.getRawObject().setNCharacterStream(parameterName, value,
				length);

	}

	@Override
	public void callableStatement_setNClob(CallableStatementProxy statement,
			String parameterName, NClob value)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setNClob(this, statement,
					parameterName, value);

			return;

		}

		statement.getRawObject().setNClob(parameterName, value);

	}

	@Override
	public void callableStatement_setClob(CallableStatementProxy statement,
			String parameterName, Reader reader,

			long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setClob(this, statement,
					parameterName, reader, length);

			return;

		}

		statement.getRawObject().setClob(parameterName, reader, length);

	}

	@Override
	public void callableStatement_setBlob(CallableStatementProxy statement,
			String parameterName,

			InputStream inputStream, long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setBlob(this, statement,
					parameterName, inputStream, length);

			return;

		}

		statement.getRawObject().setBlob(parameterName, inputStream, length);

	}

	@Override
	public void callableStatement_setNClob(CallableStatementProxy statement,
			String parameterName, Reader reader,

			long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setNClob(this, statement,
					parameterName, reader, length);

			return;

		}

		statement.getRawObject().setNClob(parameterName, reader, length);

	}

	@Override
	public NClob callableStatement_getNClob(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getNClob(this, statement,
					parameterIndex);

		}

		NClob nclob = statement.getRawObject().getNClob(parameterIndex);

		return wrap(statement.getConnectionProxy(), nclob);

	}

	@Override
	public NClob callableStatement_getNClob(CallableStatementProxy statement,
			String parameterName) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getNClob(this, statement,
					parameterName);

		}

		NClob nclob = statement.getRawObject().getNClob(parameterName);

		return wrap(statement.getConnectionProxy(), nclob);

	}

	@Override
	public void callableStatement_setSQLXML(CallableStatementProxy statement,
			String parameterName, SQLXML xmlObject)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setSQLXML(this, statement,
					parameterName, xmlObject);

			return;

		}

		statement.getRawObject().setSQLXML(parameterName, xmlObject);

	}

	@Override
	public SQLXML callableStatement_getSQLXML(CallableStatementProxy statement,
			int parameterIndex) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getSQLXML(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getSQLXML(parameterIndex);

	}

	@Override
	public SQLXML callableStatement_getSQLXML(CallableStatementProxy statement,
			String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getSQLXML(this, statement,
					parameterName);

		}

		return statement.getRawObject().getSQLXML(parameterName);

	}

	@Override
	public String callableStatement_getNString(
			CallableStatementProxy statement, int parameterIndex)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getNString(this, statement,
					parameterIndex);

		}

		return statement.getRawObject().getNString(parameterIndex);

	}

	@Override
	public String callableStatement_getNString(
			CallableStatementProxy statement, String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getNString(this, statement,
					parameterName);

		}

		return statement.getRawObject().getNString(parameterName);

	}

	@Override
	public java.io.Reader callableStatement_getNCharacterStream(
			CallableStatementProxy statement, int parameterIndex)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getNCharacterStream(this,
					statement, parameterIndex);

		}

		return statement.getRawObject().getNCharacterStream(parameterIndex);

	}

	@Override
	public java.io.Reader callableStatement_getNCharacterStream(
			CallableStatementProxy statement, String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getNCharacterStream(this,
					statement, parameterName);

		}

		return statement.getRawObject().getNCharacterStream(parameterName);

	}

	@Override
	public java.io.Reader callableStatement_getCharacterStream(
			CallableStatementProxy statement, int parameterIndex)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getCharacterStream(this,
					statement, parameterIndex);

		}

		return statement.getRawObject().getCharacterStream(parameterIndex);

	}

	@Override
	public java.io.Reader callableStatement_getCharacterStream(
			CallableStatementProxy statement, String parameterName)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().callableStatement_getCharacterStream(this,
					statement, parameterName);

		}

		return statement.getRawObject().getCharacterStream(parameterName);

	}

	@Override
	public void callableStatement_setBlob(CallableStatementProxy statement,
			String parameterName, Blob x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setBlob(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setBlob(parameterName, x);

	}

	@Override
	public void callableStatement_setClob(CallableStatementProxy statement,
			String parameterName, Clob x)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setClob(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setClob(parameterName, x);

	}

	@Override
	public void callableStatement_setAsciiStream(
			CallableStatementProxy statement, String parameterName,

			java.io.InputStream x, long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setAsciiStream(this, statement,
					parameterName, x, length);

			return;

		}

		statement.getRawObject().setAsciiStream(parameterName, x, length);

	}

	@Override
	public void callableStatement_setBinaryStream(
			CallableStatementProxy statement, String parameterName,

			java.io.InputStream x, long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setBinaryStream(this, statement,
					parameterName, x, length);

			return;

		}

		statement.getRawObject().setBinaryStream(parameterName, x, length);

	}

	@Override
	public void callableStatement_setCharacterStream(
			CallableStatementProxy statement, String parameterName,

			java.io.Reader reader, long length) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setCharacterStream(this, statement,
					parameterName, reader, length);

			return;

		}

		statement.getRawObject().setCharacterStream(parameterName, reader,
				length);

	}

	@Override
	public void callableStatement_setAsciiStream(
			CallableStatementProxy statement, String parameterName,

			java.io.InputStream x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setAsciiStream(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setAsciiStream(parameterName, x);

	}

	@Override
	public void callableStatement_setBinaryStream(
			CallableStatementProxy statement, String parameterName,

			java.io.InputStream x) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setBinaryStream(this, statement,
					parameterName, x);

			return;

		}

		statement.getRawObject().setBinaryStream(parameterName, x);

	}

	@Override
	public void callableStatement_setCharacterStream(
			CallableStatementProxy statement, String parameterName,

			java.io.Reader reader) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setCharacterStream(this, statement,
					parameterName, reader);

			return;

		}

		statement.getRawObject().setCharacterStream(parameterName, reader);

	}

	@Override
	public void callableStatement_setNCharacterStream(
			CallableStatementProxy statement, String parameterName,

			Reader value) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setNCharacterStream(this, statement,
					parameterName, value);

			return;

		}

		statement.getRawObject().setNCharacterStream(parameterName, value);

	}

	@Override
	public void callableStatement_setClob(CallableStatementProxy statement,
			String parameterName, Reader reader)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setClob(this, statement,
					parameterName, reader);

			return;

		}

		statement.getRawObject().setClob(parameterName, reader);

	}

	@Override
	public void callableStatement_setBlob(CallableStatementProxy statement,
			String parameterName,

			InputStream inputStream) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setBlob(this, statement,
					parameterName, inputStream);

			return;

		}

		statement.getRawObject().setBlob(parameterName, inputStream);

	}

	@Override
	public void callableStatement_setNClob(CallableStatementProxy statement,
			String parameterName, Reader reader)

	throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().callableStatement_setNClob(this, statement,
					parameterName, reader);

			return;

		}

		statement.getRawObject().setNClob(parameterName, reader);

	}

	@Override
	public long clob_length(ClobProxy clob) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().clob_length(this, clob);

		}

		return clob.getRawClob().length();

	}

	@Override
	public String clob_getSubString(ClobProxy clob, long pos, int length)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().clob_getSubString(this, clob, pos, length);

		}

		return clob.getRawClob().getSubString(pos, length);

	}

	@Override
	public java.io.Reader clob_getCharacterStream(ClobProxy clob)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().clob_getCharacterStream(this, clob);

		}

		return clob.getRawClob().getCharacterStream();

	}

	@Override
	public java.io.InputStream clob_getAsciiStream(ClobProxy clob)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().clob_getAsciiStream(this, clob);

		}

		return clob.getRawClob().getAsciiStream();

	}

	@Override
	public long clob_position(ClobProxy clob, String searchstr, long start)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().clob_position(this, clob, searchstr, start);

		}

		return clob.getRawClob().position(searchstr, start);

	}

	@Override
	public long clob_position(ClobProxy clob, Clob searchstr, long start)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().clob_position(this, clob, searchstr, start);

		}

		return clob.getRawClob().position(searchstr, start);

	}

	@Override
	public int clob_setString(ClobProxy clob, long pos, String str)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().clob_setString(this, clob, pos, str);

		}

		return clob.getRawClob().setString(pos, str);

	}

	@Override
	public int clob_setString(ClobProxy clob, long pos, String str, int offset,
			int len) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().clob_setString(this, clob, pos, str, offset,
					len);

		}

		return clob.getRawClob().setString(pos, str, offset, len);

	}

	@Override
	public java.io.OutputStream clob_setAsciiStream(ClobProxy clob, long pos)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().clob_setAsciiStream(this, clob, pos);

		}

		return clob.getRawClob().setAsciiStream(pos);

	}

	@Override
	public java.io.Writer clob_setCharacterStream(ClobProxy clob, long pos)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().clob_setCharacterStream(this, clob, pos);

		}

		return clob.getRawClob().setCharacterStream(pos);

	}

	@Override
	public void clob_truncate(ClobProxy clob, long len) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().clob_truncate(this, clob, len);

			return;

		}

		clob.getRawClob().truncate(len);

	}

	@Override
	public void clob_free(ClobProxy clob) throws SQLException {

		if (this.pos < filterSize) {

			nextFilter().clob_free(this, clob);

			return;

		}

		clob.getRawClob().free();

	}

	@Override
	public Reader clob_getCharacterStream(ClobProxy clob, long pos, long length)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.clob_getCharacterStream(this, clob, pos, length);

		}

		return clob.getRawClob().getCharacterStream(pos, length);

	}

	// ////////////

//	public ConnectionProxy wrap(Connection connection, Properties info) {
//
//		if (connection == null) {
//
//			return null;
//
//		}
//
//		return new ConnectionProxyImpl(dataSource, connection, info,
//				dataSource.createConnectionId());
//
//	}

	public StatementProxy wrap(ConnectionProxy connection, Statement statement) {

		if (statement == null) {

			return null;

		}

		return new StatementProxyImpl(connection, statement,
				dataSource.createStatementId());

	}

	public PreparedStatementProxy wrap(ConnectionProxy connection,
			PreparedStatement statement, String sql) {

		if (statement == null) {

			return null;

		}

		return new PreparedStatementProxyImpl(connection, statement, sql,
				dataSource.createStatementId());

	}

	public CallableStatementProxy wrap(ConnectionProxy connection,
			CallableStatement statement, String sql) {

		if (statement == null) {

			return null;

		}

		return new CallableStatementProxyImpl(connection, statement, sql,
				dataSource.createStatementId());

	}

	public ResultSetProxy wrap(StatementProxy statement, ResultSet resultSet) {

		if (resultSet == null) {

			return null;

		}

		return new ResultSetProxyImpl(statement, resultSet,
				dataSource.createResultSetId(),

				statement.getLastExecuteSql());

	}

	public ResultSetMetaDataProxy wrap(ResultSetMetaData metaData,
			ResultSetProxy resultSet) {

		if (metaData == null) {

			return null;

		}

		return new ResultSetMetaDataProxyImpl(metaData,
				dataSource.createMetaDataId(), resultSet);

	}

	public ClobProxy wrap(ConnectionProxy conn, Clob clob) {

		if (clob == null) {

			return null;

		}

		if (clob instanceof NClob) {

			return wrap(conn, (NClob) clob);

		}

		return new ClobProxyImpl(dataSource, conn, clob);

	}

	public NClobProxy wrap(ConnectionProxy conn, NClob clob) {

		if (clob == null) {

			return null;

		}

		return new NClobProxyImpl(dataSource, conn, clob);

	}

	public ClobProxy wrap(StatementProxy stmt, Clob clob) {

		if (clob == null) {

			return null;

		}

		if (clob instanceof NClob) {

			return wrap(stmt, (NClob) clob);

		}

		return new ClobProxyImpl(dataSource, stmt.getConnectionProxy(), clob);

	}

	public NClobProxy wrap(StatementProxy stmt, NClob nclob) {

		if (nclob == null) {

			return null;

		}

		return new NClobProxyImpl(dataSource, stmt.getConnectionProxy(), nclob);

	}

//	@Override
//	public void dataSource_recycle(DruidPooledConnection connection)
//			throws SQLException {
//
//		if (this.pos < filterSize) {
//
//			nextFilter().dataSource_releaseConnection(this, connection);
//
//			return;
//
//		}
//
//		connection.recycle();
//
//	}

//	@Override
//	public DruidPooledConnection dataSource_connect(DruidDataSource dataSource,
//			long maxWaitMillis) throws SQLException {
//
//		if (this.pos < filterSize) {
//
//			DruidPooledConnection conn = nextFilter().dataSource_getConnection(
//					this, dataSource, maxWaitMillis);
//
//			return conn;
//
//		}
//
//		return dataSource.getConnectionDirect(maxWaitMillis);
//
//	}

	@Override
	public int resultSetMetaData_getColumnCount(ResultSetMetaDataProxy metaData)
			throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter()
					.resultSetMetaData_getColumnCount(this, metaData);

		}

		return metaData.getResultSetMetaDataRaw().getColumnCount();

	}

	@Override
	public boolean resultSetMetaData_isAutoIncrement(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_isAutoIncrement(this,
					metaData, column);

		}

		return metaData.getResultSetMetaDataRaw().isAutoIncrement(column);

	}

	@Override
	public boolean resultSetMetaData_isCaseSensitive(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_isCaseSensitive(this,
					metaData, column);

		}

		return metaData.getResultSetMetaDataRaw().isCaseSensitive(column);

	}

	@Override
	public boolean resultSetMetaData_isSearchable(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_isSearchable(this, metaData,
					column);

		}

		return metaData.getResultSetMetaDataRaw().isSearchable(column);

	}

	@Override
	public boolean resultSetMetaData_isCurrency(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_isCurrency(this, metaData,
					column);

		}

		return metaData.getResultSetMetaDataRaw().isCurrency(column);

	}

	@Override
	public int resultSetMetaData_isNullable(ResultSetMetaDataProxy metaData,
			int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_isNullable(this, metaData,
					column);

		}

		return metaData.getResultSetMetaDataRaw().isNullable(column);

	}

	@Override
	public boolean resultSetMetaData_isSigned(ResultSetMetaDataProxy metaData,
			int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_isSigned(this, metaData,
					column);

		}

		return metaData.getResultSetMetaDataRaw().isSigned(column);

	}

	@Override
	public int resultSetMetaData_getColumnDisplaySize(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_getColumnDisplaySize(this,
					metaData, column);

		}

		return metaData.getResultSetMetaDataRaw().getColumnDisplaySize(column);

	}

	@Override
	public String resultSetMetaData_getColumnLabel(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_getColumnLabel(this,
					metaData, column);

		}

		return metaData.getResultSetMetaDataRaw().getColumnLabel(column);

	}

	@Override
	public String resultSetMetaData_getColumnName(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_getColumnName(this, metaData,
					column);

		}

		return metaData.getResultSetMetaDataRaw().getColumnName(column);

	}

	@Override
	public String resultSetMetaData_getSchemaName(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_getSchemaName(this, metaData,
					column);

		}

		return metaData.getResultSetMetaDataRaw().getSchemaName(column);

	}

	@Override
	public int resultSetMetaData_getPrecision(ResultSetMetaDataProxy metaData,
			int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_getPrecision(this, metaData,
					column);

		}

		return metaData.getResultSetMetaDataRaw().getPrecision(column);

	}

	@Override
	public int resultSetMetaData_getScale(ResultSetMetaDataProxy metaData,
			int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_getScale(this, metaData,
					column);

		}

		return metaData.getResultSetMetaDataRaw().getScale(column);

	}

	@Override
	public String resultSetMetaData_getTableName(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_getTableName(this, metaData,
					column);

		}

		return metaData.getResultSetMetaDataRaw().getTableName(column);

	}

	@Override
	public String resultSetMetaData_getCatalogName(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_getCatalogName(this,
					metaData, column);

		}

		return metaData.getResultSetMetaDataRaw().getCatalogName(column);

	}

	@Override
	public int resultSetMetaData_getColumnType(ResultSetMetaDataProxy metaData,
			int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_getColumnType(this, metaData,
					column);

		}

		return metaData.getResultSetMetaDataRaw().getColumnType(column);

	}

	@Override
	public String resultSetMetaData_getColumnTypeName(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_getColumnTypeName(this,
					metaData, column);

		}

		return metaData.getResultSetMetaDataRaw().getColumnTypeName(column);

	}

	@Override
	public boolean resultSetMetaData_isReadOnly(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_isReadOnly(this, metaData,
					column);

		}

		return metaData.getResultSetMetaDataRaw().isReadOnly(column);

	}

	@Override
	public boolean resultSetMetaData_isWritable(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_isWritable(this, metaData,
					column);

		}

		return metaData.getResultSetMetaDataRaw().isWritable(column);

	}

	@Override
	public boolean resultSetMetaData_isDefinitelyWritable(
			ResultSetMetaDataProxy metaData, int column)

	throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_isDefinitelyWritable(this,
					metaData, column);

		}

		return metaData.getResultSetMetaDataRaw().isDefinitelyWritable(column);

	}

	@Override
	public String resultSetMetaData_getColumnClassName(
			ResultSetMetaDataProxy metaData, int column) throws SQLException {

		if (this.pos < filterSize) {

			return nextFilter().resultSetMetaData_getColumnClassName(this,
					metaData, column);

		}

		return metaData.getResultSetMetaDataRaw().getColumnClassName(column);

	}
}
